/*
 * ACML version 4.3.0 Copyright AMD,NAG 2003,2004,2005
 */

/*
  This is the ACML header file. It contains function prototypes
  to allow a C programmer to call ACML routines via their C
  or Fortran interfaces.

  C interfaces to ACML routines differ from FORTRAN interfaces in
  the following major respects:

    (i) The FORTRAN interface names are in upper case.

   (ii) The C interfaces contain no workspace arguments; all
        workspace memory is allocated internally.

  (iii) Scalar input arguments are passed by value in C interfaces.
        FORTRAN interfaces pass all arguments (except for character
        string "length" arguments that are normally hidden from
        FORTRAN programmers) by reference.

   (iv) Most arguments that are passed as character string pointers
        to FORTRAN interfaces are passed by value as single
        characters to C interfaces. The character string "length"
        arguments of FORTRAN interfaces are not required in the
        C interfaces.

  It is important to note that in both the FORTRAN and C interfaces,
  2-dimensional arrays are assumed to be stored in column-major order.
  e.g. the matrix A = [ 1.0 2.0 ]
                      [ 3.0 4.0 ]
  would be stored in memory as 1.0, 3.0, 2.0, 4.0. This storage order
  corresponds to a FORTRAN-style 2-D array declaration A(2,2), but not
  to an array declared as a[2][2] in C which would be stored in
  row-major order as 1.0, 2.0, 3.0, 4.0.

  As an example, compare the FORTRAN and C interfaces of LAPACK
  routine dsytrf as implemented in ACML.
  FORTRAN:
    void DSYTRF(char *uplo, int *n, double *a, int *lda, int *ipiv,
                double *work, int *lwork, int *info, int uplo_len);

  C:
    void dsytrf(char uplo, int n, double *a, int lda, int *ipiv, int *info);

  C code calling both the above variants might look like this:

    double *a;
    int *ipiv;
    double *work;
    int n, lda, lwork, info;

    //
    // Assume that all arrays and variables are allocated and initialized
    // as required by dsytrf.
    //
    // Call the FORTRAN version of dsytrf. The first argument is a character
    // string, and the last argument is the length of that string. The input
    // scalar arguments n, lda and lwork, as well as the output scalar
    // argument info, are all passed by reference.
    DSYTRF("Upper", &n, a, &lda, ipiv, work, &lwork, &info, 5);
    //
    // Call the C version of dsytrf. The first argument is a character,
    // workspace is not required, and input scalar arguments n and lda are
    // passed by value. Output scalar argument info is passed by reference.
    dsytrf('U', n, a, lda, ipiv, &info);

*/

#ifndef _ACML_H
#define _ACML_H

/* Under Windows math.h defines "complex" to mean "_complex". */
#include <math.h>
#undef complex

#ifdef __cplusplus
extern "C" {
#endif /* __cplusplus */

/* ------------------------------------------------------------------ */

/* A complex datatype for use by the C interfaces to ACML routines */
#ifndef _ACML_COMPLEX
#define _ACML_COMPLEX
typedef struct
{
  float real, imag;
} complex;
typedef struct
{
  double real, imag;
} doublecomplex;
#endif /* !defined(_ACML_COMPLEX) */

/*
   These typedefs are for routines that are arguments to other routines,
   e.g. ACML_CGEES_SELECT describes the argument "select" of routine cgees.
 */
typedef int (* ACML_CGEES_SELECT)(complex *);
typedef int (* ACML_CGEESX_SELECT)(complex *);
typedef int (* ACML_CGGES_SELCTG)(complex *, complex *);
typedef int (* ACML_CGGESX_SELCTG)(complex *, complex *);
typedef int (* ACML_DGEES_SELECT)(double *, double *);
typedef int (* ACML_DGEESX_SELECT)(double *, double *);
typedef int (* ACML_DGGES_DELCTG)(double *, double *, double *);
typedef int (* ACML_DGGESX_DELCTG)(double *, double *, double *);
typedef int (* ACML_SGEES_SELECT)(float *, float *);
typedef int (* ACML_SGEESX_SELECT)(float *, float *);
typedef int (* ACML_SGGES_SELCTG)(float *, float *, float *);
typedef int (* ACML_SGGESX_SELCTG)(float *, float *, float *);
typedef int (* ACML_ZGEES_SELECT)(doublecomplex *);
typedef int (* ACML_ZGEESX_SELECT)(doublecomplex *);
typedef int (* ACML_ZGGES_DELCTG)(doublecomplex *, doublecomplex *);
typedef int (* ACML_ZGGESX_DELCTG)(doublecomplex *, doublecomplex *);
typedef void (* ACML_DRANDINITIALIZEUSER_UINI)(int *, int *, int *, int *, int *, int *, int *);
typedef void (* ACML_DRANDINITIALIZEUSER_UGEN)(int *, int *, double *, int *);
typedef void (* ACML_SRANDINITIALIZEUSER_UINI)(int *, int *, int *, int *, int *, int *, int *);
typedef void (* ACML_SRANDINITIALIZEUSER_UGEN)(int *, int *, float *, int *);

/* ------------------------------------------------------------------ */
/* Below are prototypes for the C interfaces to ACML routines */

/* BLAS C interfaces */
extern void caxpy(int n, complex *alpha, complex *x, int incx, complex *y, int incy);
extern void ccopy(int n, complex *x, int incx, complex *y, int incy);
extern complex cdotc(int n, complex *x, int incx, complex *y, int incy);
extern complex cdotu(int n, complex *x, int incx, complex *y, int incy);
extern void cgbmv(char transa, int m, int n, int nsub, int nsuper, complex *alpha, complex *a, int lda, complex *x, int incx, complex *beta, complex *y, int incy);
extern void cgemm(char transa, char transb, int m, int n, int k, complex *alpha, complex *a, int lda, complex *b, int ldb, complex *beta, complex *c, int ldc);
extern void cgemv(char transa, int m, int n, complex *alpha, complex *a, int lda, complex *x, int incx, complex *beta, complex *y, int incy);
extern void cgerc(int m, int n, complex *alpha, complex *x, int incx, complex *y, int incy, complex *a, int lda);
extern void cgeru(int m, int n, complex *alpha, complex *x, int incx, complex *y, int incy, complex *a, int lda);
extern void chbmv(char uplo, int n, int ndiag, complex *alpha, complex *a, int lda, complex *x, int incx, complex *beta, complex *y, int incy);
extern void chemm(char side, char uplo, int m, int n, complex *alpha, complex *a, int lda, complex *b, int ldb, complex *beta, complex *c, int ldc);
extern void chemv(char uplo, int n, complex *alpha, complex *a, int lda, complex *x, int incx, complex *beta, complex *y, int incy);
extern void cher(char uplo, int n, float alpha, complex *x, int incx, complex *a, int lda);
extern void cher2(char uplo, int n, complex *alpha, complex *x, int incx, complex *y, int incy, complex *a, int lda);
extern void cher2k(char uplo, char transa, int n, int k, complex *alpha, complex *a, int lda, complex *b, int ldb, float beta, complex *c, int ldc);
extern void cherk(char uplo, char transa, int n, int k, float alpha, complex *a, int lda, float beta, complex *c, int ldc);
extern void chpmv(char uplo, int n, complex *alpha, complex *a, complex *x, int incx, complex *beta, complex *y, int incy);
extern void chpr(char uplo, int n, float alpha, complex *x, int incx, complex *a);
extern void chpr2(char uplo, int n, complex *alpha, complex *x, int incx, complex *y, int incy, complex *a);
extern void classq(int n, complex *x, int incx, float *scale, float *sumsq);
extern void crotg(complex *a, complex *b, float *c, complex *s);
extern void cscal(int n, complex *alpha, complex *y, int incy);
extern void csrot(int n, complex *x, int incx, complex *y, int incy, float c, float s);
extern void csscal(int n, float alpha, complex *y, int incy);
extern void cstemr(char jobz, char range, int n, float *d, float *e, float vl, float vu, int il, int iu, int *m, float *w, complex *z, int ldz, int *nzc, int *isuppz, int *tryrac, int *info);
extern void cswap(int n, complex *x, int incx, complex *y, int incy);
extern void csymm(char side, char uplo, int m, int n, complex *alpha, complex *a, int lda, complex *b, int ldb, complex *beta, complex *c, int ldc);
extern void csyr2k(char uplo, char transa, int n, int k, complex *alpha, complex *a, int lda, complex *b, int ldb, complex *beta, complex *c, int ldc);
extern void csyrk(char uplo, char transa, int n, int k, complex *alpha, complex *a, int lda, complex *beta, complex *c, int ldc);
extern void ctbmv(char uplo, char transa, char diag, int n, int ndiag, complex *a, int lda, complex *y, int incy);
extern void ctbsv(char uplo, char transa, char diag, int n, int ndiag, complex *a, int lda, complex *y, int incy);
extern void ctpmv(char uplo, char transa, char diag, int n, complex *a, complex *y, int incy);
extern void ctpsv(char uplo, char transa, char diag, int n, complex *a, complex *y, int incy);
extern void ctrmm(char side, char uplo, char transa, char diag, int m, int n, complex *alpha, complex *a, int lda, complex *b, int ldb);
extern void ctrmv(char uplo, char transa, char diag, int n, complex *a, int lda, complex *y, int incy);
extern void ctrsm(char side, char uplo, char transa, char diag, int m, int n, complex *alpha, complex *a, int lda, complex *b, int ldb);
extern void ctrsv(char uplo, char transa, char diag, int n, complex *a, int lda, complex *y, int incy);
extern double dasum(int n, double *x, int incx);
extern void daxpy(int n, double alpha, double *x, int incx, double *y, int incy);
extern void dcopy(int n, double *x, int incx, double *y, int incy);
extern double ddot(int n, double *x, int incx, double *y, int incy);
extern void dgbmv(char transa, int m, int n, int nsub, int nsuper, double alpha, double *a, int lda, double *x, int incx, double beta, double *y, int incy);
extern void dgemm(char transa, char transb, int m, int n, int k, double alpha, double *a, int lda, double *b, int ldb, double beta, double *c, int ldc);
extern void dgemv(char transa, int m, int n, double alpha, double *a, int lda, double *x, int incx, double beta, double *y, int incy);
extern void dger(int m, int n, double alpha, double *x, int incx, double *y, int incy, double *a, int lda);
extern double dnrm2(int n, double *x, int incx);
extern void drot(int n, double *x, int incx, double *y, int incy, double c, double s);
extern void drotg(double *a, double *b, double *c, double *s);
extern void drotm(int n, double *x, int incx, double *y, int incy, double *param);
extern void drotmg(double d1, double d2, double b1, double b2, double *param);
extern void dsbmv(char uplo, int n, int ndiag, double alpha, double *a, int lda, double *x, int incx, double beta, double *y, int incy);
extern void dscal(int n, double alpha, double *y, int incy);
extern double dsdot(int n, float *x, int incx, float *y, int incy);
extern void dspmv(char uplo, int n, double alpha, double *a, double *x, int incx, double beta, double *y, int incy);
extern void dspr(char uplo, int n, double alpha, double *x, int incx, double *a);
extern void dspr2(char uplo, int n, double alpha, double *x, int incx, double *y, int incy, double *a);
extern void dswap(int n, double *x, int incx, double *y, int incy);
extern void dsymm(char side, char uplo, int m, int n, double alpha, double *a, int lda, double *b, int ldb, double beta, double *c, int ldc);
extern void dsymv(char uplo, int n, double alpha, double *a, int lda, double *x, int incx, double beta, double *y, int incy);
extern void dsyr(char uplo, int n, double alpha, double *x, int incx, double *a, int lda);
extern void dsyr2(char uplo, int n, double alpha, double *x, int incx, double *y, int incy, double *a, int lda);
extern void dsyr2k(char uplo, char transa, int n, int k, double alpha, double *a, int lda, double *b, int ldb, double beta, double *c, int ldc);
extern void dsyrk(char uplo, char transa, int n, int k, double alpha, double *a, int lda, double beta, double *c, int ldc);
extern void dtbmv(char uplo, char transa, char diag, int n, int ndiag, double *a, int lda, double *y, int incy);
extern void dtbsv(char uplo, char transa, char diag, int n, int ndiag, double *a, int lda, double *y, int incy);
extern void dtpmv(char uplo, char transa, char diag, int n, double *a, double *y, int incy);
extern void dtpsv(char uplo, char transa, char diag, int n, double *a, double *y, int incy);
extern void dtrmm(char side, char uplo, char transa, char diag, int m, int n, double alpha, double *a, int lda, double *b, int ldb);
extern void dtrmv(char uplo, char transa, char diag, int n, double *a, int lda, double *y, int incy);
extern void dtrsm(char side, char uplo, char transa, char diag, int m, int n, double alpha, double *a, int lda, double *b, int ldb);
extern void dtrsv(char uplo, char transa, char diag, int n, double *a, int lda, double *y, int incy);
extern double dzasum(int n, doublecomplex *x, int incx);
extern double dznrm2(int n, doublecomplex *x, int incx);
extern int icamax(int n, complex *x, int incx);
extern int idamax(int n, double *x, int incx);
extern int isamax(int n, float *x, int incx);
extern int izamax(int n, doublecomplex *x, int incx);
extern int lsame(char ca, char cb);
extern float sasum(int n, float *x, int incx);
extern void saxpy(int n, float alpha, float *x, int incx, float *y, int incy);
extern float scasum(int n, complex *x, int incx);
extern float scnrm2(int n, complex *x, int incx);
extern void scopy(int n, float *x, int incx, float *y, int incy);
extern float sdot(int n, float *x, int incx, float *y, int incy);
extern float sdsdot(int n, float sb, float *sx, int incx, float *sy, int incy);
extern void sgbmv(char transa, int m, int n, int nsub, int nsuper, float alpha, float *a, int lda, float *x, int incx, float beta, float *y, int incy);
extern void sgemm(char transa, char transb, int m, int n, int k, float alpha, float *a, int lda, float *b, int ldb, float beta, float *c, int ldc);
extern void sgemv(char transa, int m, int n, float alpha, float *a, int lda, float *x, int incx, float beta, float *y, int incy);
extern void sger(int m, int n, float alpha, float *x, int incx, float *y, int incy, float *a, int lda);
extern float snrm2(int n, float *x, int incx);
extern void srot(int n, float *x, int incx, float *y, int incy, float c, float s);
extern void srotg(float *a, float *b, float *c, float *s);
extern void srotm(int n, float *x, int incx, float *y, int incy, float *param);
extern void srotmg(float d1, float d2, float b1, float b2, float *param);
extern void ssbmv(char uplo, int n, int ndiag, float alpha, float *a, int lda, float *x, int incx, float beta, float *y, int incy);
extern void sscal(int n, float alpha, float *x, int incx);
extern void sspmv(char uplo, int n, float alpha, float *a, float *x, int incx, float beta, float *y, int incy);
extern void sspr(char uplo, int n, float alpha, float *x, int incx, float *a);
extern void sspr2(char uplo, int n, float alpha, float *x, int incx, float *y, int incy, float *a);
extern void sstemr(char jobz, char range, int n, float *d, float *e, float vl, float vu, int il, int iu, int *m, float *w, float *z, int ldz, int *nzc, int *isuppz, int *tryrac, int *info);
extern void sswap(int n, float *x, int incx, float *y, int incy);
extern void ssymm(char side, char uplo, int m, int n, float alpha, float *a, int lda, float *b, int ldb, float beta, float *c, int ldc);
extern void ssymv(char uplo, int n, float alpha, float *a, int lda, float *x, int incx, float beta, float *y, int incy);
extern void ssyr(char uplo, int n, float alpha, float *x, int incx, float *a, int lda);
extern void ssyr2(char uplo, int n, float alpha, float *x, int incx, float *y, int incy, float *a, int lda);
extern void ssyr2k(char uplo, char transa, int n, int k, float alpha, float *a, int lda, float *b, int ldb, float beta, float *c, int ldc);
extern void ssyrk(char uplo, char transa, int n, int k, float alpha, float *a, int lda, float beta, float *c, int ldc);
extern void stbmv(char uplo, char transa, char diag, int n, int ndiag, float *a, int lda, float *y, int incy);
extern void stbsv(char uplo, char transa, char diag, int n, int ndiag, float *a, int lda, float *y, int incy);
extern void stpmv(char uplo, char transa, char diag, int n, float *a, float *y, int incy);
extern void stpsv(char uplo, char transa, char diag, int n, float *a, float *y, int incy);
extern void strmm(char side, char uplo, char transa, char diag, int m, int n, float alpha, float *a, int lda, float *b, int ldb);
extern void strmv(char uplo, char transa, char diag, int n, float *a, int lda, float *y, int incy);
extern void strsm(char side, char uplo, char transa, char diag, int m, int n, float alpha, float *a, int lda, float *b, int ldb);
extern void strsv(char uplo, char transa, char diag, int n, float *a, int lda, float *y, int incy);
extern void xerbla(const char *srname, int *info);
extern void zaxpy(int n, doublecomplex *alpha, doublecomplex *x, int incx, doublecomplex *y, int incy);
extern void zcopy(int n, doublecomplex *x, int incx, doublecomplex *y, int incy);
extern doublecomplex zdotc(int n, doublecomplex *x, int incx, doublecomplex *y, int incy);
extern doublecomplex zdotu(int n, doublecomplex *x, int incx, doublecomplex *y, int incy);
extern void zdrot(int n, doublecomplex *cx, int incx, doublecomplex *cy, int incy, double c, double s);
extern void zdscal(int n, double alpha, doublecomplex *y, int incy);
extern void zgbmv(char transa, int m, int n, int nsub, int nsuper, doublecomplex *alpha, doublecomplex *a, int lda, doublecomplex *x, int incx, doublecomplex *beta, doublecomplex *y, int incy);
extern void zgemm(char transa, char transb, int m, int n, int k, doublecomplex *alpha, doublecomplex *a, int lda, doublecomplex *b, int ldb, doublecomplex *beta, doublecomplex *c, int ldc);
extern void zgemv(char transa, int m, int n, doublecomplex *alpha, doublecomplex *a, int lda, doublecomplex *x, int incx, doublecomplex *beta, doublecomplex *y, int incy);
extern void zgerc(int m, int n, doublecomplex *alpha, doublecomplex *x, int incx, doublecomplex *y, int incy, doublecomplex *a, int lda);
extern void zgeru(int m, int n, doublecomplex *alpha, doublecomplex *x, int incx, doublecomplex *y, int incy, doublecomplex *a, int lda);
extern void zhbmv(char uplo, int n, int ndiag, doublecomplex *alpha, doublecomplex *a, int lda, doublecomplex *x, int incx, doublecomplex *beta, doublecomplex *y, int incy);
extern void zhemm(char side, char uplo, int m, int n, doublecomplex *alpha, doublecomplex *a, int lda, doublecomplex *b, int ldb, doublecomplex *beta, doublecomplex *c, int ldc);
extern void zhemv(char uplo, int n, doublecomplex *alpha, doublecomplex *a, int lda, doublecomplex *x, int incx, doublecomplex *beta, doublecomplex *y, int incy);
extern void zher(char uplo, int n, double alpha, doublecomplex *x, int incx, doublecomplex *a, int lda);
extern void zher2(char uplo, int n, doublecomplex *alpha, doublecomplex *x, int incx, doublecomplex *y, int incy, doublecomplex *a, int lda);
extern void zher2k(char uplo, char transa, int n, int k, doublecomplex *alpha, doublecomplex *a, int lda, doublecomplex *b, int ldb, double beta, doublecomplex *c, int ldc);
extern void zherk(char uplo, char transa, int n, int k, double alpha, doublecomplex *a, int lda, double beta, doublecomplex *c, int ldc);
extern void zhpmv(char uplo, int n, doublecomplex *alpha, doublecomplex *a, doublecomplex *x, int incx, doublecomplex *beta, doublecomplex *y, int incy);
extern void zhpr(char uplo, int n, double alpha, doublecomplex *x, int incx, doublecomplex *a);
extern void zhpr2(char uplo, int n, doublecomplex *alpha, doublecomplex *x, int incx, doublecomplex *y, int incy, doublecomplex *a);
extern void zlassq(int n, doublecomplex *x, int incx, double *scale, double *sumsq);
extern void zrotg(doublecomplex *a, doublecomplex *b, double *c, doublecomplex *s);
extern void zscal(int n, doublecomplex *alpha, doublecomplex *y, int incy);
extern void zstemr(char jobz, char range, int n, double *d, double *e, double vl, double vu, int il, int iu, int *m, double *w, doublecomplex *z, int ldz, int *nzc, int *isuppz, int *tryrac, int *info);
extern void zswap(int n, doublecomplex *x, int incx, doublecomplex *y, int incy);
extern void zsymm(char side, char uplo, int m, int n, doublecomplex *alpha, doublecomplex *a, int lda, doublecomplex *b, int ldb, doublecomplex *beta, doublecomplex *c, int ldc);
extern void zsyr2k(char uplo, char transa, int n, int k, doublecomplex *alpha, doublecomplex *a, int lda, doublecomplex *b, int ldb, doublecomplex *beta, doublecomplex *c, int ldc);
extern void zsyrk(char uplo, char transa, int n, int k, doublecomplex *alpha, doublecomplex *a, int lda, doublecomplex *beta, doublecomplex *c, int ldc);
extern void ztbmv(char uplo, char transa, char diag, int n, int ndiag, doublecomplex *a, int lda, doublecomplex *y, int incy);
extern void ztbsv(char uplo, char transa, char diag, int n, int ndiag, doublecomplex *a, int lda, doublecomplex *y, int incy);
extern void ztpmv(char uplo, char transa, char diag, int n, doublecomplex *a, doublecomplex *y, int incy);
extern void ztpsv(char uplo, char transa, char diag, int n, doublecomplex *a, doublecomplex *y, int incy);
extern void ztrmm(char side, char uplo, char transa, char diag, int m, int n, doublecomplex *alpha, doublecomplex *a, int lda, doublecomplex *b, int ldb);
extern void ztrmv(char uplo, char transa, char diag, int n, doublecomplex *a, int lda, doublecomplex *y, int incy);
extern void ztrsm(char side, char uplo, char transa, char diag, int m, int n, doublecomplex *alpha, doublecomplex *a, int lda, doublecomplex *b, int ldb);
extern void ztrsv(char uplo, char transa, char diag, int n, doublecomplex *a, int lda, doublecomplex *y, int incy);

/* LAPACK C interfaces */
extern int ilaenv(int ispec, const char *name, const char *opts, int n1, int n2, int n3, int n4);
extern void ilaenvset(int ispec, const char *name, const char *opts, int n1, int n2, int n3, int n4, int nvalue, int *info);
extern void ilaver(int *vers_major, int *vers_minor, int *vers_patch);
extern void cbdsqr(char uplo, int n, int ncvt, int nru, int ncc, float *d, float *e, complex *vt, int ldvt, complex *u, int ldu, complex *c, int ldc, int *info);
extern void cgbbrd(char vect, int m, int n, int ncc, int kl, int ku, complex *ab, int ldab, float *d, float *e, complex *q, int ldq, complex *pt, int ldpt, complex *c, int ldc, int *info);
extern void cgbcon(char norm, int n, int nsub, int nsuper, complex *a, int lda, int *ipiv, float anorm, float *rcond, int *info);
extern void cgbequ(int m, int n, int nsub, int nsuper, complex *a, int lda, float *rowsc, float *colsc, float *rowcnd, float *colcnd, float *amax, int *info);
extern void cgbrfs(char transa, int n, int nsub, int nsuper, int nrhs, complex *a, int lda, complex *af, int ldaf, int *ipiv, complex *b, int ldb, complex *x, int ldx, float *ferr, float *berr, int *info);
extern void cgbsv(int n, int nsub, int nsuper, int nrhs, complex *a, int lda, int *ipiv, complex *b, int ldb, int *info);

/* N.B. In this C interface to cgbsvx, rpvgrw returns what is returned in
   the first element of RWORK by the FORTRAN interface */
extern void cgbsvx(char fact, char transa, int n, int nsub, int nsuper, int nrhs, complex *a, int lda, complex *af, int ldaf, int *ipiv, char equed, float *rowsc, float *colsc, complex *b, int ldb, complex *x, int ldx, float *rcond, float *ferr, float *berr, float *rpvgrw, int *info);

extern void cgbtrf(int m, int n, int nsub, int nsuper, complex *a, int lda, int *ipiv, int *info);
extern void cgbtrs(char transa, int n, int nsub, int nsuper, int nrhs, complex *a, int lda, int *ipiv, complex *b, int ldb, int *info);
extern void cgebak(char job, char side, int n, int ilo, int ihi, float *scale, int m, complex *v, int ldv, int *info);
extern void cgebal(char job, int n, complex *a, int lda, int *ilo, int *ihi, float *scale, int *info);
extern void cgebrd(int m, int n, complex *a, int lda, float *d, float *e, complex *tauq, complex *taup, int *info);
extern void cgecon(char norm, int n, complex *a, int lda, float anorm, float *rcond, int *info);
extern void cgeequ(int m, int n, complex *a, int lda, float *rowsc, float *colsc, float *rowcnd, float *colcnd, float *amax, int *info);
extern void cgees(char jobz, char sortev, ACML_CGEES_SELECT select, int n, complex *a, int lda, int *nout, complex *w, complex *z, int ldz, int *info);
extern void cgeesx(char jobz, char sortev, ACML_CGEESX_SELECT select, char sense, int n, complex *a, int lda, int *nout, complex *w, complex *z, int ldz, float *rcone, float *rconv, int *info);
extern void cgeev(char jobvl, char jobvr, int n, complex *a, int lda, complex *w, complex *vl, int ldvl, complex *vr, int ldvr, int *info);
extern void cgeevx(char balanc, char jobvl, char jobvr, char sense, int n, complex *a, int lda, complex *w, complex *vl, int ldvl, complex *vr, int ldvr, int *ilo, int *ihi, float *scale, float *abnrm, float *rconde, float *rcondv, int *info);
extern void cgegs(char jobvsl, char jobvsr, int n, complex *a, int lda, complex *b, int ldb, complex *alpha, complex *beta, complex *vsl, int ldvsl, complex *vsr, int ldvsr, int *info);
extern void cgegv(char jobvl, char jobvr, int n, complex *a, int lda, complex *b, int ldb, complex *alpha, complex *beta, complex *vl, int ldvl, complex *vr, int ldvr, int *info);
extern void cgehrd(int n, int ilo, int ihi, complex *a, int lda, complex *tau, int *info);
extern void cgelqf(int m, int n, complex *a, int lda, complex *tau, int *info);
extern void cgels(char trans, int m, int n, int nrhs, complex *a, int lda, complex *b, int ldb, int *info);
extern void cgelsd(int m, int n, int nrhs, complex *a, int lda, complex *b, int ldb, float *s, float rcond, int *rank, int *info);
extern void cgelss(int m, int n, int nrhs, complex *a, int lda, complex *b, int ldb, float *sing, float rcond, int *irank, int *info);
extern void cgelsx(int m, int n, int nrhs, complex *a, int lda, complex *b, int ldb, int *jpivot, float rcond, int *irank, int *info);
extern void cgelsy(int m, int n, int nrhs, complex *a, int lda, complex *b, int ldb, int *jpvt, float rcond, int *rank, int *info);
extern void cgeqlf(int m, int n, complex *a, int lda, complex *tau, int *info);
extern void cgeqp3(int m, int n, complex *a, int lda, int *jpvt, complex *tau, int *info);
extern void cgeqpf(int m, int n, complex *a, int lda, int *jpvt, complex *tau, int *info);
extern void cgeqrf(int m, int n, complex *a, int lda, complex *tau, int *info);
extern void cgerfs(char transa, int n, int nrhs, complex *a, int lda, complex *af, int ldaf, int *ipiv, complex *b, int ldb, complex *x, int ldx, float *ferr, float *berr, int *info);
extern void cgerqf(int m, int n, complex *a, int lda, complex *tau, int *info);
extern void cgesdd(char jobz, int m, int n, complex *a, int lda, float *s, complex *u, int ldu, complex *vt, int ldvt, int *info);
extern void cgesv(int n, int nrhs, complex *a, int lda, int *ipiv, complex *b, int ldb, int *info);
extern void cgesvd(char jobu, char jobvt, int m, int n, complex *a, int lda, float *sing, complex *u, int ldu, complex *vt, int ldvt, int *info);

/* N.B. In this C interface to cgesvx, rpvgrw returns what is returned in
   the first element of RWORK by the FORTRAN interface */
extern void cgesvx(char fact, char transa, int n, int nrhs, complex *a, int lda, complex *af, int ldaf, int *ipiv, char equed, float *rowsc, float *colsc, complex *b, int ldb, complex *x, int ldx, float *rcond, float *ferr, float *berr, float *rpvgrw, int *info);

extern void cgetrf(int m, int n, complex *a, int lda, int *ipiv, int *info);
extern void cgetri(int n, complex *a, int lda, int *ipiv, int *info);
extern void cgetrs(char transa, int n, int nrhs, complex *a, int lda, int *ipiv, complex *b, int ldb, int *info);
extern void cggbak(char job, char side, int n, int ilo, int ihi, float *lscale, float *rscale, int m, complex *v, int ldv, int *info);
extern void cggbal(char job, int n, complex *a, int lda, complex *b, int ldb, int *ilo, int *ihi, float *lscale, float *rscale, int *info);
extern void cgges(char jobvsl, char jobvsr, char sort, ACML_CGGES_SELCTG selctg, int n, complex *a, int lda, complex *b, int ldb, int *sdim, complex *alpha, complex *beta, complex *vsl, int ldvsl, complex *vsr, int ldvsr, int *info);
extern void cggesx(char jobvsl, char jobvsr, char sort, ACML_CGGESX_SELCTG selctg, char sense, int n, complex *a, int lda, complex *b, int ldb, int *sdim, complex *alpha, complex *beta, complex *vsl, int ldvsl, complex *vsr, int ldvsr, float *rconde, float *rcondv, int *info);
extern void cggev(char jobvl, char jobvr, int n, complex *a, int lda, complex *b, int ldb, complex *alpha, complex *beta, complex *vl, int ldvl, complex *vr, int ldvr, int *info);
extern void cggevx(char balanc, char jobvl, char jobvr, char sense, int n, complex *a, int lda, complex *b, int ldb, complex *alpha, complex *beta, complex *vl, int ldvl, complex *vr, int ldvr, int *ilo, int *ihi, float *lscale, float *rscale, float *abnrm, float *bbnrm, float *rconde, float *rcondv, int *info);
extern void cggglm(int n, int m, int p, complex *a, int lda, complex *b, int ldb, complex *d, complex *x, complex *y, int *info);
extern void cgghrd(char compq, char compz, int n, int ilo, int ihi, complex *a, int lda, complex *b, int ldb, complex *q, int ldq, complex *z, int ldz, int *info);
extern void cgglse(int m, int n, int p, complex *a, int lda, complex *b, int ldb, complex *c, complex *d, complex *x, int *info);
extern void cggqrf(int n, int m, int p, complex *a, int lda, complex *taua, complex *b, int ldb, complex *taub, int *info);
extern void cggrqf(int m, int p, int n, complex *a, int lda, complex *taua, complex *b, int ldb, complex *taub, int *info);
extern void cggsvd(char jobu, char jobv, char jobq, int m, int n, int p, int *k, int *l, complex *a, int lda, complex *b, int ldb, float *alpha, float *beta, complex *u, int ldu, complex *v, int ldv, complex *q, int ldq, int *iwork, int *info);
extern void cggsvp(char jobu, char jobv, char jobq, int m, int p, int n, complex *a, int lda, complex *b, int ldb, float tola, float tolb, int *k, int *l, complex *u, int ldu, complex *v, int ldv, complex *q, int ldq, int *info);
extern void cgtcon(char norm, int n, complex *low, complex *diag, complex *up1, complex *up2, int *ipiv, float anorm, float *rcond, int *info);
extern void cgtrfs(char transa, int n, int nrhs, complex *low, complex *diag, complex *up, complex *lowf, complex *diagf, complex *upf1, complex *upf2, int *ipiv, complex *b, int ldb, complex *x, int ldx, float *ferr, float *berr, int *info);
extern void cgtsv(int n, int nrhs, complex *low, complex *diag, complex *up, complex *b, int ldb, int *info);
extern void cgtsvx(char fact, char transa, int n, int nrhs, complex *low, complex *diag, complex *up, complex *lowf, complex *diagf, complex *upf1, complex *upf2, int *ipiv, complex *b, int ldb, complex *x, int ldx, float *rcond, float *ferr, float *berr, int *info);
extern void cgttrf(int n, complex *low, complex *diag, complex *up1, complex *up2, int *ipiv, int *info);
extern void cgttrs(char transa, int n, int nrhs, complex *low, complex *diag, complex *up1, complex *up2, int *ipiv, complex *b, int ldb, int *info);
extern void chbev(char jobz, char uplo, int n, int ndiag, complex *a, int lda, float *w, complex *z, int ldz, int *info);
extern void chbevd(char jobz, char uplo, int n, int kd, complex *ab, int ldab, float *w, complex *z, int ldz, int *info);
extern void chbevx(char jobz, char range, char uplo, int n, int ndiag, complex *a, int lda, complex *q, int ldq, float vl, float vu, int il, int iu, float abtol, int *nfound, float *w, complex *z, int ldz, int *ifail, int *info);
extern void chbgst(char vect, char uplo, int n, int ka, int kb, complex *ab, int ldab, complex *bb, int ldbb, complex *x, int ldx, int *info);
extern void chbgv(char jobz, char uplo, int n, int ka, int kb, complex *ab, int ldab, complex *bb, int ldbb, float *w, complex *z, int ldz, int *info);
extern void chbgvd(char jobz, char uplo, int n, int ka, int kb, complex *ab, int ldab, complex *bb, int ldbb, float *w, complex *z, int ldz, int *info);
extern void chbgvx(char jobz, char range, char uplo, int n, int ka, int kb, complex *ab, int ldab, complex *bb, int ldbb, complex *q, int ldq, float vl, float vu, int il, int iu, float abstol, int *m, float *w, complex *z, int ldz, int *ifail, int *info);
extern void chbtrd(char vect, char uplo, int n, int kd, complex *ab, int ldab, float *d, float *e, complex *q, int ldq, int *info);
extern void checon(char uplo, int n, complex *a, int lda, int *ipiv, float anorm, float *rcond, int *info);
extern void cheev(char jobz, char uplo, int n, complex *a, int lda, float *w, int *info);
extern void cheevd(char jobz, char uplo, int n, complex *a, int lda, float *w, int *info);
extern void cheevr(char jobz, char range, char uplo, int n, complex *a, int lda, float vl, float vu, int il, int iu, float abstol, int *m, float *w, complex *z, int ldz, int *isuppz, int *info);
extern void cheevx(char jobz, char range, char uplo, int n, complex *a, int lda, float vl, float vu, int il, int iu, float abtol, int *nfound, float *w, complex *z, int ldz, int *ifail, int *info);
extern void chegst(int itype, char uplo, int n, complex *a, int lda, complex *b, int ldb, int *info);
extern void chegv(int itype, char jobz, char uplo, int n, complex *a, int lda, complex *b, int ldb, float *w, int *info);
extern void chegvd(int itype, char jobz, char uplo, int n, complex *a, int lda, complex *b, int ldb, float *w, int *info);
extern void chegvx(int itype, char jobz, char range, char uplo, int n, complex *a, int lda, complex *b, int ldb, float vl, float vu, int il, int iu, float abstol, int *m, float *w, complex *z, int ldz, int *ifail, int *info);
extern void cherfs(char uplo, int n, int nrhs, complex *a, int lda, complex *af, int ldaf, int *ipiv, complex *b, int ldb, complex *x, int ldx, float *ferr, float *berr, int *info);
extern void chesv(char uplo, int n, int nrhs, complex *a, int lda, int *ipiv, complex *b, int ldb, int *info);
extern void chesvx(char fact, char uplo, int n, int nrhs, complex *a, int lda, complex *af, int ldaf, int *ipiv, complex *b, int ldb, complex *x, int ldx, float *rcond, float *ferr, float *berr, int *info);
extern void chetrd(char uplo, int n, complex *a, int lda, float *d, float *e, complex *tau, int *info);
extern void chetrf(char uplo, int n, complex *a, int lda, int *ipiv, int *info);
extern void chetri(char uplo, int n, complex *a, int lda, int *ipiv, int *info);
extern void chetrs(char uplo, int n, int nrhs, complex *a, int lda, int *ipiv, complex *b, int ldb, int *info);
extern void chgeqz(char job, char compq, char compz, int n, int ilo, int ihi, complex *a, int lda, complex *b, int ldb, complex *alpha, complex *beta, complex *q, int ldq, complex *z, int ldz, int *info);
extern void chpcon(char uplo, int n, complex *a, int *ipiv, float anorm, float *rcond, int *info);
extern void chpev(char jobz, char uplo, int n, complex *a, float *w, complex *z, int ldz, int *info);
extern void chpevd(char jobz, char uplo, int n, complex *ap, float *w, complex *z, int ldz, int *info);
extern void chpevx(char jobz, char range, char uplo, int n, complex *a, float vl, float vu, int il, int iu, float abtol, int *nfound, float *w, complex *z, int ldz, int *ifail, int *info);
extern void chpgst(int itype, char uplo, int n, complex *ap, complex *bp, int *info);
extern void chpgv(int itype, char jobz, char uplo, int n, complex *a, complex *b, float *w, complex *z, int ldz, int *info);
extern void chpgvd(int itype, char jobz, char uplo, int n, complex *ap, complex *bp, float *w, complex *z, int ldz, int *info);
extern void chpgvx(int itype, char jobz, char range, char uplo, int n, complex *ap, complex *bp, float vl, float vu, int il, int iu, float abstol, int *m, float *w, complex *z, int ldz, int *ifail, int *info);
extern void chprfs(char uplo, int n, int nrhs, complex *a, complex *af, int *ipiv, complex *b, int ldb, complex *x, int ldx, float *ferr, float *berr, int *info);
extern void chpsv(char uplo, int n, int nrhs, complex *a, int *ipiv, complex *b, int ldb, int *info);
extern void chpsvx(char fact, char uplo, int n, int nrhs, complex *a, complex *af, int *ipiv, complex *b, int ldb, complex *x, int ldx, float *rcond, float *ferr, float *berr, int *info);
extern void chptrd(char uplo, int n, complex *ap, float *d, float *e, complex *tau, int *info);
extern void chptrf(char uplo, int n, complex *a, int *ipiv, int *info);
extern void chptri(char uplo, int n, complex *a, int *ipiv, int *info);
extern void chptrs(char uplo, int n, int nrhs, complex *a, int *ipiv, complex *b, int ldb, int *info);
extern void chsein(char side, char eigsrc, char initv, int *select, int n, complex *h, int ldh, complex *w, complex *vl, int ldvl, complex *vr, int ldvr, int mm, int *m, int *ifaill, int *ifailr, int *info);
extern void chseqr(char job, char compz, int n, int ilo, int ihi, complex *h, int ldh, complex *w, complex *z, int ldz, int *info);
extern void cpbcon(char uplo, int n, int ndiag, complex *a, int lda, float anorm, float *rcond, int *info);
extern void cpbequ(char uplo, int n, int ndiag, complex *a, int lda, float *scale, float *scond, float *amax, int *info);
extern void cpbrfs(char uplo, int n, int ndiag, int nrhs, complex *a, int lda, complex *af, int ldaf, complex *b, int ldb, complex *x, int ldx, float *ferr, float *berr, int *info);
extern void cpbstf(char uplo, int n, int kd, complex *ab, int ldab, int *info);
extern void cpbsv(char uplo, int n, int ndiag, int nrhs, complex *a, int lda, complex *b, int ldb, int *info);
extern void cpbsvx(char fact, char uplo, int n, int ndiag, int nrhs, complex *a, int lda, complex *af, int ldaf, char equed, float *scale, complex *b, int ldb, complex *x, int ldx, float *rcond, float *ferr, float *berr, int *info);
extern void cpbtrf(char uplo, int n, int ndiag, complex *a, int lda, int *info);
extern void cpbtrs(char uplo, int n, int ndiag, int nrhs, complex *a, int lda, complex *b, int ldb, int *info);
extern void cpocon(char uplo, int n, complex *a, int lda, float anorm, float *rcond, int *info);
extern void cpoequ(int n, complex *a, int lda, float *scale, float *scond, float *amax, int *info);
extern void cporfs(char uplo, int n, int nrhs, complex *a, int lda, complex *af, int ldaf, complex *b, int ldb, complex *x, int ldx, float *ferr, float *berr, int *info);
extern void cposv(char uplo, int n, int nrhs, complex *a, int lda, complex *b, int ldb, int *info);
extern void cposvx(char fact, char uplo, int n, int nrhs, complex *a, int lda, complex *af, int ldaf, char equed, float *scale, complex *b, int ldb, complex *x, int ldx, float *rcond, float *ferr, float *berr, int *info);
extern void cpotrf(char uplo, int n, complex *a, int lda, int *info);
extern void cpotri(char uplo, int n, complex *a, int lda, int *info);
extern void cpotrs(char uplo, int n, int nrhs, complex *a, int lda, complex *b, int ldb, int *info);
extern void cppcon(char uplo, int n, complex *a, float anorm, float *rcond, int *info);
extern void cppequ(char uplo, int n, complex *a, float *scale, float *scond, float *amax, int *info);
extern void cpprfs(char uplo, int n, int nrhs, complex *a, complex *af, complex *b, int ldb, complex *x, int ldx, float *ferr, float *berr, int *info);
extern void cppsv(char uplo, int n, int nrhs, complex *a, complex *b, int ldb, int *info);
extern void cppsvx(char fact, char uplo, int n, int nrhs, complex *a, complex *af, char equed, float *scale, complex *b, int ldb, complex *x, int ldx, float *rcond, float *ferr, float *berr, int *info);
extern void cpptrf(char uplo, int n, complex *a, int *info);
extern void cpptri(char uplo, int n, complex *a, int *info);
extern void cpptrs(char uplo, int n, int nrhs, complex *a, complex *b, int ldb, int *info);
extern void cptcon(int n, float *diag, complex *offd, float anorm, float *rcond, int *info);
extern void cpteqr(char compz, int n, float *d, float *e, complex *z, int ldz, int *info);
extern void cptrfs(char uplo, int n, int nrhs, float *diag, complex *offd, float *diagf, complex *offdf, complex *b, int ldb, complex *x, int ldx, float *ferr, float *berr, int *info);
extern void cptsv(int n, int nrhs, float *diag, complex *sub, complex *b, int ldb, int *info);
extern void cptsvx(char fact, int n, int nrhs, float *diag, complex *sub, float *diagf, complex *subf, complex *b, int ldb, complex *x, int ldx, float *rcond, float *ferr, float *berr, int *info);
extern void cpttrf(int n, float *diag, complex *offd, int *info);
extern void cpttrs(char uplo, int n, int nrhs, float *diag, complex *offd, complex *b, int ldb, int *info);
extern void cspcon(char uplo, int n, complex *a, int *ipiv, float anorm, float *rcond, int *info);
extern void csprfs(char uplo, int n, int nrhs, complex *a, complex *af, int *ipiv, complex *b, int ldb, complex *x, int ldx, float *ferr, float *berr, int *info);
extern void cspsv(char uplo, int n, int nrhs, complex *a, int *ipiv, complex *b, int ldb, int *info);
extern void cspsvx(char fact, char uplo, int n, int nrhs, complex *a, complex *af, int *ipiv, complex *b, int ldb, complex *x, int ldx, float *rcond, float *ferr, float *berr, int *info);
extern void csptrf(char uplo, int n, complex *a, int *ipiv, int *info);
extern void csptri(char uplo, int n, complex *a, int *ipiv, int *info);
extern void csptrs(char uplo, int n, int nrhs, complex *a, int *ipiv, complex *b, int ldb, int *info);
extern void cstedc(char compz, int n, float *d, float *e, complex *z, int ldz, int *info);
extern void cstegr(char jobz, char range, int n, float *d, float *e, float vl, float vu, int il, int iu, float abstol, int *m, float *w, complex *z, int ldz, int *isuppz, int *info);
extern void cstein(int n, float *d, float *e, int m, float *w, int *iblock, int *isplit, complex *z, int ldz, int *ifail, int *info);
extern void csteqr(char compz, int n, float *d, float *e, complex *z, int ldz, int *info);
extern void csycon(char uplo, int n, complex *a, int lda, int *ipiv, float anorm, float *rcond, int *info);
extern void csyrfs(char uplo, int n, int nrhs, complex *a, int lda, complex *af, int ldaf, int *ipiv, complex *b, int ldb, complex *x, int ldx, float *ferr, float *berr, int *info);
extern void csysv(char uplo, int n, int nrhs, complex *a, int lda, int *ipiv, complex *b, int ldb, int *info);
extern void csysvx(char fact, char uplo, int n, int nrhs, complex *a, int lda, complex *af, int ldaf, int *ipiv, complex *b, int ldb, complex *x, int ldx, float *rcond, float *ferr, float *berr, int *info);
extern void csytrf(char uplo, int n, complex *a, int lda, int *ipiv, int *info);
extern void csytri(char uplo, int n, complex *a, int lda, int *ipiv, int *info);
extern void csytrs(char uplo, int n, int nrhs, complex *a, int lda, int *ipiv, complex *b, int ldb, int *info);
extern void ctbcon(char norm, char uplo, char diag, int n, int ndiag, complex *a, int lda, float *rcond, int *info);
extern void ctbrfs(char uplo, char transa, char diag, int n, int ndiag, int nrhs, complex *a, int lda, complex *b, int ldb, complex *x, int ldx, float *ferr, float *berr, int *info);
extern void ctbtrs(char uplo, char transa, char diag, int n, int ndiag, int nrhs, complex *a, int lda, complex *b, int ldb, int *info);
extern void ctgevc(char side, char howmny, int *select, int n, complex *a, int lda, complex *b, int ldb, complex *vl, int ldvl, complex *vr, int ldvr, int mm, int *m, int *info);
extern void ctgexc(int wantq, int wantz, int n, complex *a, int lda, complex *b, int ldb, complex *q, int ldq, complex *z, int ldz, int *ifst, int *ilst, int *info);
extern void ctgsen(int ijob, int wantq, int wantz, int *select, int n, complex *a, int lda, complex *b, int ldb, complex *alpha, complex *beta, complex *q, int ldq, complex *z, int ldz, int *m, float *pl, float *pr, float *dif, int *info);
extern void ctgsja(char jobu, char jobv, char jobq, int m, int p, int n, int k, int l, complex *a, int lda, complex *b, int ldb, float tola, float tolb, float *alpha, float *beta, complex *u, int ldu, complex *v, int ldv, complex *q, int ldq, int *ncycle, int *info);
extern void ctgsna(char job, char howmnt, int *select, int n, complex *a, int lda, complex *b, int ldb, complex *vl, int ldvl, complex *vr, int ldvr, float *s, float *dif, int mm, int *m, int *info);
extern void ctgsyl(char trans, int ijob, int m, int n, complex *a, int lda, complex *b, int ldb, complex *c, int ldc, complex *d, int ldd, complex *e, int lde, complex *f, int ldf, float *scale, float *dif, int *info);
extern void ctpcon(char norm, char uplo, char diag, int n, complex *a, float *rcond, int *info);
extern void ctprfs(char uplo, char transa, char diag, int n, int nrhs, complex *a, complex *b, int ldb, complex *x, int ldx, float *ferr, float *berr, int *info);
extern void ctptri(char uplo, char diag, int n, complex *a, int *info);
extern void ctptrs(char uplo, char transa, char diag, int n, int nrhs, complex *a, complex *b, int ldb, int *info);
extern void ctrcon(char norm, char uplo, char diag, int n, complex *a, int lda, float *rcond, int *info);
extern void ctrevc(char side, char howmny, int *select, int n, complex *t, int ldt, complex *vl, int ldvl, complex *vr, int ldvr, int mm, int *m, int *info);
extern void ctrexc(char compq, int n, complex *t, int ldt, complex *q, int ldq, int ifst, int ilst, int *info);
extern void ctrrfs(char uplo, char transa, char diag, int n, int nrhs, complex *a, int lda, complex *b, int ldb, complex *x, int ldx, float *ferr, float *berr, int *info);
extern void ctrsen(char job, char compq, int *select, int n, complex *t, int ldt, complex *q, int ldq, complex *w, int *m, float *s, float *sep, int *info);
extern void ctrsna(char job, char howmny, int *select, int n, complex *t, int ldt, complex *vl, int ldvl, complex *vr, int ldvr, float *s, float *sep, int mm, int *m, int *info);
extern void ctrsyl(char trana, char tranb, int isgn, int m, int n, complex *a, int lda, complex *b, int ldb, complex *c, int ldc, float *scale, int *info);
extern void ctrtri(char uplo, char diag, int n, complex *a, int lda, int *info);
extern void ctrtrs(char uplo, char transa, char diag, int n, int nrhs, complex *a, int lda, complex *b, int ldb, int *info);
extern void ctzrqf(int m, int n, complex *a, int lda, complex *tau, int *info);
extern void ctzrzf(int m, int n, complex *a, int lda, complex *tau, int *info);
extern void cungbr(char vect, int m, int n, int k, complex *a, int lda, complex *tau, int *info);
extern void cunghr(int n, int ilo, int ihi, complex *a, int lda, complex *tau, int *info);
extern void cunglq(int m, int n, int k, complex *a, int lda, complex *tau, int *info);
extern void cungql(int m, int n, int k, complex *a, int lda, complex *tau, int *info);
extern void cungqr(int m, int n, int k, complex *a, int lda, complex *tau, int *info);
extern void cungrq(int m, int n, int k, complex *a, int lda, complex *tau, int *info);
extern void cungtr(char uplo, int n, complex *a, int lda, complex *tau, int *info);
extern void cunmbr(char vect, char side, char trans, int m, int n, int k, complex *a, int lda, complex *tau, complex *c, int ldc, int *info);
extern void cunmhr(char side, char trans, int m, int n, int ilo, int ihi, complex *a, int lda, complex *tau, complex *c, int ldc, int *info);
extern void cunmlq(char side, char trans, int m, int n, int k, complex *a, int lda, complex *tau, complex *c, int ldc, int *info);
extern void cunmql(char side, char trans, int m, int n, int k, complex *a, int lda, complex *tau, complex *c, int ldc, int *info);
extern void cunmqr(char side, char trans, int m, int n, int k, complex *a, int lda, complex *tau, complex *c, int ldc, int *info);
extern void cunmrq(char side, char trans, int m, int n, int k, complex *a, int lda, complex *tau, complex *c, int ldc, int *info);
extern void cunmrz(char side, char trans, int m, int n, int k, int l, complex *a, int lda, complex *tau, complex *c, int ldc, int *info);
extern void cunmtr(char side, char uplo, char trans, int m, int n, complex *a, int lda, complex *tau, complex *c, int ldc, int *info);
extern void cupgtr(char uplo, int n, complex *ap, complex *tau, complex *q, int ldq, int *info);
extern void cupmtr(char side, char uplo, char trans, int m, int n, complex *ap, complex *tau, complex *c, int ldc, int *info);
extern void dbdsdc(char uplo, char compq, int n, double *d, double *e, double *u, int ldu, double *vt, int ldvt, double *q, int *iq, int *info);
extern void dbdsqr(char uplo, int n, int ncvt, int nru, int ncc, double *d, double *e, double *vt, int ldvt, double *u, int ldu, double *c, int ldc, int *info);
extern void ddisna(char job, int m, int n, double *d, double *sep, int *info);
extern void dgbbrd(char vect, int m, int n, int ncc, int kl, int ku, double *ab, int ldab, double *d, double *e, double *q, int ldq, double *pt, int ldpt, double *c, int ldc, int *info);
extern void dgbcon(char norm, int n, int nsub, int nsuper, double *a, int lda, int *ipiv, double anorm, double *rcond, int *info);
extern void dgbequ(int m, int n, int nsub, int nsuper, double *a, int lda, double *rowsc, double *colsc, double *rowcn, double *colcn, double *amax, int *info);
extern void dgbrfs(char transa, int n, int nsub, int nsuper, int nrhs, double *a, int lda, double *af, int ldaf, int *ipiv, double *b, int ldb, double *x, int ldx, double *ferr, double *berr, int *info);
extern void dgbsv(int n, int nsub, int nsuper, int nrhs, double *a, int lda, int *ipiv, double *b, int ldb, int *info);

/* N.B. In this C interface to dgbsvx, rpvgrw returns what is returned in
   the first element of WORK by the FORTRAN interface */
extern void dgbsvx(char fact, char transa, int n, int nsub, int nsuper, int nrhs, double *a, int lda, double *af, int ldaf, int *ipiv, char equed, double *rowsc, double *colsc, double *b, int ldb, double *x, int ldx, double *rcond, double *ferr, double *berr, double *rpvgrw, int *info);

extern void dgbtrf(int m, int n, int nsub, int nsuper, double *a, int lda, int *ipiv, int *info);
extern void dgbtrs(char transa, int n, int nsub, int nsuper, int nrhs, double *a, int lda, int *ipiv, double *b, int ldb, int *info);
extern void dgebak(char job, char side, int n, int ilo, int ihi, double *scale, int m, double *v, int ldv, int *info);
extern void dgebal(char job, int n, double *a, int lda, int *ilo, int *ihi, double *scale, int *info);
extern void dgebrd(int m, int n, double *a, int lda, double *d, double *e, double *tauq, double *taup, int *info);
extern void dgecon(char norm, int n, double *a, int lda, double anorm, double *rcond, int *info);
extern void dgeequ(int m, int n, double *a, int lda, double *rowsc, double *colsc, double *rowcn, double *colcn, double *amax, int *info);
extern void dgees(char jobz, char sortev, ACML_DGEES_SELECT select, int n, double *a, int lda, int *nout, double *wr, double *wi, double *z, int ldz, int *info);
extern void dgeesx(char jobz, char sortev, ACML_DGEESX_SELECT select, char sense, int n, double *a, int lda, int *nout, double *wr, double *wi, double *z, int ldz, double *srcone, double *rconv, int *info);
extern void dgeev(char jobvl, char jobvr, int n, double *a, int lda, double *wr, double *wi, double *vl, int ldvl, double *vr, int ldvr, int *info);
extern void dgeevx(char balanc, char jobvl, char jobvr, char sense, int n, double *a, int lda, double *wr, double *wi, double *vl, int ldvl, double *vr, int ldvr, int *ilo, int *ihi, double *scale, double *abnrm, double *rcone, double *rconv, int *info);
extern void dgegs(char jobvsl, char jobvsr, int n, double *a, int lda, double *b, int ldb, double *alphar, double *alphai, double *beta, double *vsl, int ldvsl, double *vsr, int ldvsr, int *info);
extern void dgegv(char jobvl, char jobvr, int n, double *a, int lda, double *b, int ldb, double *alphar, double *alphai, double *beta, double *vl, int ldvl, double *vr, int ldvr, int *info);
extern void dgehrd(int n, int ilo, int ihi, double *a, int lda, double *tau, int *info);
extern void dgelqf(int m, int n, double *a, int lda, double *tau, int *info);
extern void dgels(char trans, int m, int n, int nrhs, double *a, int lda, double *b, int ldb, int *info);
extern void dgelsd(int m, int n, int nrhs, double *a, int lda, double *b, int ldb, double *s, double rcond, int *rank, int *info);
extern void dgelss(int m, int n, int nrhs, double *a, int lda, double *b, int ldb, double *sing, double rcond, int *irank, int *info);
extern void dgelsx(int m, int n, int nrhs, double *a, int lda, double *b, int ldb, int *jpivot, double rcond, int *irank, int *info);
extern void dgelsy(int m, int n, int nrhs, double *a, int lda, double *b, int ldb, int *jpvt, double rcond, int *rank, int *info);
extern void dgeqlf(int m, int n, double *a, int lda, double *tau, int *info);
extern void dgeqp3(int m, int n, double *a, int lda, int *jpvt, double *tau, int *info);
extern void dgeqpf(int m, int n, double *a, int lda, int *jpivot, double *tau, int *info);
extern void dgeqrf(int m, int n, double *a, int lda, double *tau, int *info);
extern void dgerfs(char transa, int n, int nrhs, double *a, int lda, double *af, int ldaf, int *ipiv, double *b, int ldb, double *x, int ldx, double *ferr, double *berr, int *info);
extern void dgerqf(int m, int n, double *a, int lda, double *tau, int *info);
extern void dgesdd(char jobz, int m, int n, double *a, int lda, double *s, double *u, int ldu, double *vt, int ldvt, int *info);
extern void dgesv(int n, int nrhs, double *a, int lda, int *ipiv, double *b, int ldb, int *info);
extern void dgesvd(char jobu, char jobvt, int m, int n, double *a, int lda, double *sing, double *u, int ldu, double *vt, int ldvt, int *info);

/* N.B. In this C interface to dgesvx, rpvgrw returns what is returned in
   the first element of WORK by the FORTRAN interface */
extern void dgesvx(char fact, char transa, int n, int nrhs, double *a, int lda, double *af, int ldaf, int *ipiv, char equed, double *rowsc, double *colsc, double *b, int ldb, double *x, int ldx, double *rcond, double *ferr, double *berr, double *rpvgrw, int *info);

extern void dgetrf(int m, int n, double *a, int lda, int *ipiv, int *info);
extern void dgetri(int n, double *a, int lda, int *ipiv, int *info);
extern void dgetrs(char transa, int n, int nrhs, double *a, int lda, int *ipiv, double *b, int ldb, int *info);
extern void dggbak(char job, char side, int n, int ilo, int ihi, double *lscale, double *rscale, int m, double *v, int ldv, int *info);
extern void dggbal(char job, int n, double *a, int lda, double *b, int ldb, int *ilo, int *ihi, double *lscale, double *rscale, int *info);
extern void dgges(char jobvsl, char jobvsr, char sort, ACML_DGGES_DELCTG delctg, int n, double *a, int lda, double *b, int ldb, int *sdim, double *alphar, double *alphai, double *beta, double *vsl, int ldvsl, double *vsr, int ldvsr, int *info);
extern void dggesx(char jobvsl, char jobvsr, char sort, ACML_DGGESX_DELCTG delctg, char sense, int n, double *a, int lda, double *b, int ldb, int *sdim, double *alphar, double *alphai, double *beta, double *vsl, int ldvsl, double *vsr, int ldvsr, double *rconde, double *rcondv, int *info);
extern void dggev(char jobvl, char jobvr, int n, double *a, int lda, double *b, int ldb, double *alphar, double *alphai, double *beta, double *vl, int ldvl, double *vr, int ldvr, int *info);
extern void dggevx(char balanc, char jobvl, char jobvr, char sense, int n, double *a, int lda, double *b, int ldb, double *alphar, double *alphai, double *beta, double *vl, int ldvl, double *vr, int ldvr, int *ilo, int *ihi, double *lscale, double *rscale, double *abnrm, double *bbnrm, double *rconde, double *rcondv, int *info);
extern void dggglm(int n, int m, int p, double *a, int lda, double *b, int ldb, double *d, double *x, double *y, int *info);
extern void dgghrd(char compq, char compz, int n, int ilo, int ihi, double *a, int lda, double *b, int ldb, double *q, int ldq, double *z, int ldz, int *info);
extern void dgglse(int m, int n, int p, double *a, int lda, double *b, int ldb, double *c, double *d, double *x, int *info);
extern void dggqrf(int n, int m, int p, double *a, int lda, double *taua, double *b, int ldb, double *taub, int *info);
extern void dggrqf(int m, int p, int n, double *a, int lda, double *taua, double *b, int ldb, double *taub, int *info);
extern void dggsvd(char jobu, char jobv, char jobq, int m, int n, int p, int *k, int *l, double *a, int lda, double *b, int ldb, double *alpha, double *beta, double *u, int ldu, double *v, int ldv, double *q, int ldq, int *iwork3, int *info);
extern void dggsvp(char jobu, char jobv, char jobq, int m, int p, int n, double *a, int lda, double *b, int ldb, double tola, double tolb, int *k, int *l, double *u, int ldu, double *v, int ldv, double *q, int ldq, int *info);
extern void dgtcon(char norm, int n, double *low, double *diag, double *up1, double *up2, int *ipiv, double anorm, double *rcond, int *info);
extern void dgtrfs(char transa, int n, int nrhs, double *low, double *diag, double *up, double *lowf, double *diagf, double *upf1, double *upf2, int *ipiv, double *b, int ldb, double *x, int ldx, double *ferr, double *berr, int *info);
extern void dgtsv(int n, int nrhs, double *low, double *diag, double *up, double *b, int ldb, int *info);
extern void dgtsvx(char fact, char transa, int n, int nrhs, double *low, double *diag, double *up, double *lowf, double *diagf, double *upf1, double *upf2, int *ipiv, double *b, int ldb, double *x, int ldx, double *rcond, double *ferr, double *berr, int *info);
extern void dgttrf(int n, double *low, double *diag, double *up1, double *up2, int *ipiv, int *info);
extern void dgttrs(char transa, int n, int nrhs, double *low, double *diag, double *up1, double *up2, int *ipiv, double *b, int ldb, int *info);
extern void dhgeqz(char job, char compq, char compz, int n, int ilo, int ihi, double *a, int lda, double *b, int ldb, double *alphar, double *alphai, double *beta, double *q, int ldq, double *z, int ldz, int *info);
extern void dhsein(char side, char eigsrc, char initv, int *select, int n, double *h, int ldh, double *wr, double *wi, double *vl, int ldvl, double *vr, int ldvr, int mm, int *m, int *ifaill, int *ifailr, int *info);
extern void dhseqr(char job, char compz, int n, int ilo, int ihi, double *h, int ldh, double *wr, double *wi, double *z, int ldz, int *info);
extern int disnan(double *din);
extern double dlamch(char cmach);
extern void dlasrt(char id, int n, double *d, int *info);
extern void dlassq(int n, double *x, int incx, double *scale, double *sumsq);
extern void dopgtr(char uplo, int n, double *ap, double *tau, double *q, int ldq, int *info);
extern void dopmtr(char side, char uplo, char trans, int m, int n, double *ap, double *tau, double *c, int ldc, int *info);
extern void dorgbr(char vect, int m, int n, int k, double *a, int lda, double *tau, int *info);
extern void dorghr(int n, int ilo, int ihi, double *a, int lda, double *tau, int *info);
extern void dorglq(int m, int n, int k, double *a, int lda, double *tau, int *info);
extern void dorgql(int m, int n, int k, double *a, int lda, double *tau, int *info);
extern void dorgqr(int m, int n, int k, double *a, int lda, double *tau, int *info);
extern void dorgrq(int m, int n, int k, double *a, int lda, double *tau, int *info);
extern void dorgtr(char uplo, int n, double *a, int lda, double *tau, int *info);
extern void dormbr(char vect, char side, char trans, int m, int n, int k, double *a, int lda, double *tau, double *c, int ldc, int *info);
extern void dormhr(char side, char trans, int m, int n, int ilo, int ihi, double *a, int lda, double *tau, double *c, int ldc, int *info);
extern void dormlq(char side, char trans, int m, int n, int k, double *a, int lda, double *tau, double *c, int ldc, int *info);
extern void dormql(char side, char trans, int m, int n, int k, double *a, int lda, double *tau, double *c, int ldc, int *info);
extern void dormqr(char side, char trans, int m, int n, int k, double *a, int lda, double *tau, double *c, int ldc, int *info);
extern void dormr3(char side, char trans, int m, int n, int k, int l, double *a, int lda, double *tau, double *c, int ldc, int *info);
extern void dormrq(char side, char trans, int m, int n, int k, double *a, int lda, double *tau, double *c, int ldc, int *info);
extern void dormrz(char side, char trans, int m, int n, int k, int l, double *a, int lda, double *tau, double *c, int ldc, int *info);
extern void dormtr(char side, char uplo, char trans, int m, int n, double *a, int lda, double *tau, double *c, int ldc, int *info);
extern void dpbcon(char uplo, int n, int ndiag, double *a, int lda, double anorm, double *rcond, int *info);
extern void dpbequ(char uplo, int n, int ndiag, double *a, int lda, double *scale, double *scond, double *amax, int *info);
extern void dpbrfs(char uplo, int n, int ndiag, int nrhs, double *a, int lda, double *af, int ldaf, double *b, int ldb, double *x, int ldx, double *ferr, double *berr, int *info);
extern void dpbstf(char uplo, int n, int kd, double *ab, int ldab, int *info);
extern void dpbsv(char uplo, int n, int ndiag, int nrhs, double *a, int lda, double *b, int ldb, int *info);
extern void dpbsvx(char fact, char uplo, int n, int ndiag, int nrhs, double *a, int lda, double *af, int ldaf, char equed, double *scale, double *b, int ldb, double *x, int ldx, double *rcond, double *ferr, double *berr, int *info);
extern void dpbtrf(char uplo, int n, int ndiag, double *a, int lda, int *info);
extern void dpbtrs(char uplo, int n, int ndiag, int nrhs, double *a, int lda, double *b, int ldb, int *info);
extern void dpocon(char uplo, int n, double *a, int lda, double anorm, double *rcond, int *info);
extern void dpoequ(int n, double *a, int lda, double *scale, double *scond, double *amax, int *info);
extern void dporfs(char uplo, int n, int nrhs, double *a, int lda, double *af, int ldaf, double *b, int ldb, double *x, int ldx, double *ferr, double *berr, int *info);
extern void dposv(char uplo, int n, int nrhs, double *a, int lda, double *b, int ldb, int *info);
extern void dposvx(char fact, char uplo, int n, int nrhs, double *a, int lda, double *af, int ldaf, char equed, double *scale, double *b, int ldb, double *x, int ldx, double *rcond, double *ferr, double *berr, int *info);
extern void dpotrf(char uplo, int n, double *a, int lda, int *info);
extern void dpotri(char uplo, int n, double *a, int lda, int *info);
extern void dpotrs(char uplo, int n, int nrhs, double *a, int lda, double *b, int ldb, int *info);
extern void dppcon(char uplo, int n, double *a, double anorm, double *rcond, int *info);
extern void dppequ(char uplo, int n, double *a, double *scale, double *scond, double *amax, int *info);
extern void dpprfs(char uplo, int n, int nrhs, double *a, double *af, double *b, int ldb, double *x, int ldx, double *ferr, double *berr, int *info);
extern void dppsv(char uplo, int n, int nrhs, double *a, double *b, int ldb, int *info);
extern void dppsvx(char fact, char uplo, int n, int nrhs, double *a, double *af, char equed, double *scale, double *b, int ldb, double *x, int ldx, double *rcond, double *ferr, double *berr, int *info);
extern void dpptrf(char uplo, int n, double *a, int *info);
extern void dpptri(char uplo, int n, double *a, int *info);
extern void dpptrs(char uplo, int n, int nrhs, double *a, double *b, int ldb, int *info);
extern void dptcon(int n, double *diag, double *offd, double anorm, double *rcond, int *info);
extern void dpteqr(char compz, int n, double *d, double *e, double *z, int ldz, int *info);
extern void dptrfs(int n, int nrhs, double *diag, double *offd, double *diagf, double *offdf, double *b, int ldb, double *x, int ldx, double *ferr, double *berr, int *info);
extern void dptsv(int n, int nrhs, double *diag, double *sub, double *b, int ldb, int *info);
extern void dptsvx(char fact, int n, int nrhs, double *diag, double *sub, double *diagf, double *subf, double *b, int ldb, double *x, int ldx, double *rcond, double *ferr, double *berr, int *info);
extern void dpttrf(int n, double *diag, double *offd, int *info);
extern void dpttrs(int n, int nrhs, double *diag, double *offd, double *b, int ldb, int *info);
extern void dsbev(char jobz, char uplo, int n, int ndiag, double *a, int lda, double *w, double *z, int ldz, int *info);
extern void dsbevd(char jobz, char uplo, int n, int kd, double *ab, int ldab, double *w, double *z, int ldz, int *info);
extern void dsbevx(char jobz, char range, char uplo, int n, int ndiag, double *a, int lda, double *q, int ldq, double vl, double vu, int il, int iu, double abtol, int *nfound, double *w, double *z, int ldz, int *ifail, int *info);
extern void dsbgst(char vect, char uplo, int n, int ka, int kb, double *ab, int ldab, double *bb, int ldbb, double *x, int ldx, int *info);
extern void dsbgv(char jobz, char uplo, int n, int ka, int kb, double *ab, int ldab, double *bb, int ldbb, double *w, double *z, int ldz, int *info);
extern void dsbgvd(char jobz, char uplo, int n, int ka, int kb, double *ab, int ldab, double *bb, int ldbb, double *w, double *z, int ldz, int *info);
extern void dsbgvx(char jobz, char range, char uplo, int n, int ka, int kb, double *ab, int ldab, double *bb, int ldbb, double *q, int ldq, double vl, double vu, int il, int iu, double abstol, int *m, double *w, double *z, int ldz, int *ifail, int *info);
extern void dsbtrd(char vect, char uplo, int n, int kd, double *ab, int ldab, double *d, double *e, double *q, int ldq, int *info);
extern double dsecnd(void);
extern void dsgesv(int n, int nrhs, double *a, int lda, int *ipiv, double *b, int ldb, double *x, int ldx, double *work, float *swork, int *iter, int *info);
extern void dspcon(char uplo, int n, double *a, int *ipiv, double anorm, double *rcond, int *info);
extern void dspev(char jobz, char uplo, int n, double *a, double *w, double *z, int ldz, int *info);
extern void dspevd(char jobz, char uplo, int n, double *ap, double *w, double *z, int ldz, int *info);
extern void dspevx(char jobz, char range, char uplo, int n, double *a, double vl, double vu, int il, int iu, double abtol, int *nfound, double *w, double *z, int ldz, int *ifail, int *info);
extern void dspgst(int itype, char uplo, int n, double *ap, double *bp, int *info);
extern void dspgv(int itype, char jobz, char uplo, int n, double *a, double *b, double *w, double *z, int ldz, int *info);
extern void dspgvd(int itype, char jobz, char uplo, int n, double *ap, double *bp, double *w, double *z, int ldz, int *info);
extern void dspgvx(int itype, char jobz, char range, char uplo, int n, double *ap, double *bp, double vl, double vu, int il, int iu, double abstol, int *m, double *w, double *z, int ldz, int *ifail, int *info);
extern void dsprfs(char uplo, int n, int nrhs, double *a, double *af, int *ipiv, double *b, int ldb, double *x, int ldx, double *ferr, double *berr, int *info);
extern void dspsv(char uplo, int n, int nrhs, double *a, int *ipiv, double *b, int ldb, int *info);
extern void dspsvx(char fact, char uplo, int n, int nrhs, double *a, double *af, int *ipiv, double *b, int ldb, double *x, int ldx, double *rcond, double *ferr, double *berr, int *info);
extern void dsptrd(char uplo, int n, double *ap, double *d, double *e, double *tau, int *info);
extern void dsptrf(char uplo, int n, double *a, int *ipiv, int *info);
extern void dsptri(char uplo, int n, double *a, int *ipiv, int *info);
extern void dsptrs(char uplo, int n, int nrhs, double *a, int *ipiv, double *b, int ldb, int *info);
extern void dstebz(char range, char order, int n, double vl, double vu, int il, int iu, double abstol, double *d, double *e, int *m, int *nsplit, double *w, int *iblock, int *isplit, int *info);
extern void dstedc(char compz, int n, double *d, double *e, double *z, int ldz, int *info);
extern void dstegr(char jobz, char range, int n, double *d, double *e, double vl, double vu, int il, int iu, double abstol, int *m, double *w, double *z, int ldz, int *isuppz, int *info);
extern void dstein(int n, double *d, double *e, int m, double *w, int *iblock, int *isplit, double *z, int ldz, int *ifail, int *info);
extern void dstemr(char jobz, char range, int n, double *d, double *e, double vl, double vu, int il, int iu, int *m, double *w, double *z, int ldz, int *nzc, int *isuppz, int *tryrac, int *info);
extern void dsteqr(char compz, int n, double *d, double *e, double *z, int ldz, int *info);
extern void dsterf(int n, double *d, double *e, int *info);
extern void dstev(char jobz, int n, double *diag, double *offd, double *z, int ldz, int *info);
extern void dstevd(char jobz, int n, double *d, double *e, double *z, int ldz, int *info);
extern void dstevr(char jobz, char range, int n, double *d, double *e, double vl, double vu, int il, int iu, double abstol, int *m, double *w, double *z, int ldz, int *isuppz, int *info);
extern void dstevx(char jobz, char range, int n, double *diag, double *offd, double vl, double vu, int il, int iu, double abtol, int *nfound, double *w, double *z, int ldz, int *ifail, int *info);
extern void dsycon(char uplo, int n, double *a, int lda, int *ipiv, double anorm, double *rcond, int *info);
extern void dsyev(char jobz, char uplo, int n, double *a, int lda, double *w, int *info);
extern void dsyevd(char jobz, char uplo, int n, double *a, int lda, double *w, int *info);
extern void dsyevr(char jobz, char range, char uplo, int n, double *a, int lda, double vl, double vu, int il, int iu, double abstol, int *m, double *w, double *z, int ldz, int *isuppz, int *info);
extern void dsyevx(char jobz, char range, char uplo, int n, double *a, int lda, double vl, double vu, int il, int iu, double abtol, int *nfound, double *w, double *z, int ldz, int *ifail, int *info);
extern void dsygst(int itype, char uplo, int n, double *a, int lda, double *b, int ldb, int *info);
extern void dsygv(int itype, char jobz, char uplo, int n, double *a, int lda, double *b, int ldb, double *w, int *info);
extern void dsygvd(int itype, char jobz, char uplo, int n, double *a, int lda, double *b, int ldb, double *w, int *info);
extern void dsygvx(int itype, char jobz, char range, char uplo, int n, double *a, int lda, double *b, int ldb, double vl, double vu, int il, int iu, double abstol, int *m, double *w, double *z, int ldz, int *ifail, int *info);
extern void dsyrfs(char uplo, int n, int nrhs, double *a, int lda, double *af, int ldaf, int *ipiv, double *b, int ldb, double *x, int ldx, double *ferr, double *berr, int *info);
extern void dsysv(char uplo, int n, int nrhs, double *a, int lda, int *ipiv, double *b, int ldb, int *info);
extern void dsysvx(char fact, char uplo, int n, int nrhs, double *a, int lda, double *af, int ldaf, int *ipiv, double *b, int ldb, double *x, int ldx, double *rcond, double *ferr, double *berr, int *info);
extern void dsytrd(char uplo, int n, double *a, int lda, double *d, double *e, double *tau, int *info);
extern void dsytrf(char uplo, int n, double *a, int lda, int *ipiv, int *info);
extern void dsytri(char uplo, int n, double *a, int lda, int *ipiv, int *info);
extern void dsytrs(char uplo, int n, int nrhs, double *a, int lda, int *ipiv, double *b, int ldb, int *info);
extern void dtbcon(char norm, char uplo, char diag, int n, int ndiag, double *a, int lda, double *rcond, int *info);
extern void dtbrfs(char uplo, char transa, char diag, int n, int ndiag, int nrhs, double *a, int lda, double *b, int ldb, double *x, int ldx, double *ferr, double *berr, int *info);
extern void dtbtrs(char uplo, char transa, char diag, int n, int ndiag, int nrhs, double *a, int lda, double *b, int ldb, int *info);
extern void dtgevc(char side, char howmny, int *select, int n, double *a, int lda, double *b, int ldb, double *vl, int ldvl, double *vr, int ldvr, int mm, int *m, int *info);
extern void dtgexc(int wantq, int wantz, int n, double *a, int lda, double *b, int ldb, double *q, int ldq, double *z, int ldz, int *ifst, int *ilst, int *info);
extern void dtgsen(int ijob, int wantq, int wantz, int *select, int n, double *a, int lda, double *b, int ldb, double *alphar, double *alphai, double *beta, double *q, int ldq, double *z, int ldz, int *m, double *pl, double *pr, double *dif, int *info);
extern void dtgsja(char jobu, char jobv, char jobq, int m, int p, int n, int k, int l, double *a, int lda, double *b, int ldb, double tola, double tolb, double *alpha, double *beta, double *u, int ldu, double *v, int ldv, double *q, int ldq, int *ncycle, int *info);
extern void dtgsna(char job, char howmnt, int *select, int n, double *a, int lda, double *b, int ldb, double *vl, int ldvl, double *vr, int ldvr, double *s, double *dif, int mm, int *m, int *info);
extern void dtgsyl(char trans, int ijob, int m, int n, double *a, int lda, double *b, int ldb, double *c, int ldc, double *d, int ldd, double *e, int lde, double *f, int ldf, double *scale, double *dif, int *info);
extern void dtpcon(char norm, char uplo, char diag, int n, double *a, double *rcond, int *info);
extern void dtprfs(char uplo, char transa, char diag, int n, int nrhs, double *a, double *b, int ldb, double *x, int ldx, double *ferr, double *berr, int *info);
extern void dtptri(char uplo, char diag, int n, double *a, int *info);
extern void dtptrs(char uplo, char transa, char diag, int n, int nrhs, double *a, double *b, int ldb, int *info);
extern void dtrcon(char norm, char uplo, char diag, int n, double *a, int lda, double *rcond, int *info);
extern void dtrevc(char side, char howmny, int *select, int n, double *t, int ldt, double *vl, int ldvl, double *vr, int ldvr, int mm, int *m, int *info);
extern void dtrexc(char compq, int n, double *t, int ldt, double *q, int ldq, int *ifst, int *ilst, int *info);
extern void dtrrfs(char uplo, char transa, char diag, int n, int nrhs, double *a, int lda, double *b, int ldb, double *x, int ldx, double *ferr, double *berr, int *info);
extern void dtrsen(char job, char compq, int *select, int n, double *t, int ldt, double *q, int ldq, double *wr, double *wi, int *m, double *s, double *sep, int *info);
extern void dtrsna(char job, char howmny, int *select, int n, double *t, int ldt, double *vl, int ldvl, double *vr, int ldvr, double *s, double *sep, int mm, int *m, int *info);
extern void dtrsyl(char trana, char tranb, int isgn, int m, int n, double *a, int lda, double *b, int ldb, double *c, int ldc, double *scale, int *info);
extern void dtrtri(char uplo, char diag, int n, double *a, int lda, int *info);
extern void dtrtrs(char uplo, char transa, char diag, int n, int nrhs, double *a, int lda, double *b, int ldb, int *info);
extern void dtzrqf(int m, int n, double *a, int lda, double *tau, int *info);
extern void dtzrzf(int m, int n, double *a, int lda, double *tau, int *info);
extern void sbdsdc(char uplo, char compq, int n, float *d, float *e, float *u, int ldu, float *vt, int ldvt, float *q, int *iq, int *info);
extern void sbdsqr(char uplo, int n, int ncvt, int nru, int ncc, float *d, float *e, float *vt, int ldvt, float *u, int ldu, float *c, int ldc, int *info);
extern void sdisna(char job, int m, int n, float *d, float *sep, int *info);
extern float second(void);
extern void sgbbrd(char vect, int m, int n, int ncc, int kl, int ku, float *ab, int ldab, float *d, float *e, float *q, int ldq, float *pt, int ldpt, float *c, int ldc, int *info);
extern void sgbcon(char norm, int n, int nsub, int nsuper, float *a, int lda, int *ipiv, float anorm, float *rcond, int *info);
extern void sgbequ(int m, int n, int nsub, int nsuper, float *a, int lda, float *rowsc, float *colsc, float *rowcn, float *colcn, float *amax, int *info);
extern void sgbrfs(char transa, int n, int nsub, int nsuper, int nrhs, float *a, int lda, float *af, int ldaf, int *ipiv, float *b, int ldb, float *x, int ldx, float *ferr, float *berr, int *info);
extern void sgbsv(int n, int nsub, int nsuper, int nrhs, float *a, int lda, int *ipiv, float *b, int ldb, int *info);

/* N.B. In this C interface to sgbsvx, rpvgrw returns what is returned in
   the first element of WORK by the FORTRAN interface */
extern void sgbsvx(char fact, char transa, int n, int nsub, int nsuper, int nrhs, float *a, int lda, float *af, int ldaf, int *ipiv, char equed, float *rowsc, float *colsc, float *b, int ldb, float *x, int ldx, float *rcond, float *ferr, float *berr, float *rpvgrw, int *info);

extern void sgbtrf(int m, int n, int nsub, int nsuper, float *a, int lda, int *ipiv, int *info);
extern void sgbtrs(char transa, int n, int nsub, int nsuper, int nrhs, float *a, int lda, int *ipiv, float *b, int ldb, int *info);
extern void sgebak(char job, char side, int n, int ilo, int ihi, float *scale, int m, float *v, int ldv, int *info);
extern void sgebal(char job, int n, float *a, int lda, int *ilo, int *ihi, float *scale, int *info);
extern void sgebrd(int m, int n, float *a, int lda, float *d, float *e, float *tauq, float *taup, int *info);
extern void sgecon(char norm, int n, float *a, int lda, float anorm, float *rcond, int *info);
extern void sgeequ(int m, int n, float *a, int lda, float *rowsc, float *colsc, float *rowcn, float *colcn, float *amax, int *info);
extern void sgees(char jobz, char sortev, ACML_SGEES_SELECT select, int n, float *a, int lda, int *nout, float *wr, float *wi, float *z, int ldz, int *info);
extern void sgeesx(char jobz, char sortev, ACML_SGEESX_SELECT select, char sense, int n, float *a, int lda, int *nout, float *wr, float *wi, float *z, int ldz, float *srcone, float *rconv, int *info);
extern void sgeev(char jobvl, char jobvr, int n, float *a, int lda, float *wr, float *wi, float *vl, int ldvl, float *vr, int ldvr, int *info);
extern void sgeevx(char balanc, char jobvl, char jobvr, char sense, int n, float *a, int lda, float *wr, float *wi, float *vl, int ldvl, float *vr, int ldvr, int *ilo, int *ihi, float *scale, float *abnrm, float *rcone, float *rconv, int *info);
extern void sgegs(char jobvsl, char jobvsr, int n, float *a, int lda, float *b, int ldb, float *alphar, float *alphai, float *beta, float *vsl, int ldvsl, float *vsr, int ldvsr, int *info);
extern void sgegv(char jobvl, char jobvr, int n, float *a, int lda, float *b, int ldb, float *alphar, float *alphai, float *beta, float *vl, int ldvl, float *vr, int ldvr, int *info);
extern void sgehrd(int n, int ilo, int ihi, float *a, int lda, float *tau, int *info);
extern void sgelqf(int m, int n, float *a, int lda, float *tau, int *info);
extern void sgels(char trans, int m, int n, int nrhs, float *a, int lda, float *b, int ldb, int *info);
extern void sgelsd(int m, int n, int nrhs, float *a, int lda, float *b, int ldb, float *s, float rcond, int *rank, int *info);
extern void sgelss(int m, int n, int nrhs, float *a, int lda, float *b, int ldb, float *sing, float rcond, int *irank, int *info);
extern void sgelsx(int m, int n, int nrhs, float *a, int lda, float *b, int ldb, int *jpivot, float rcond, int *irank, int *info);
extern void sgelsy(int m, int n, int nrhs, float *a, int lda, float *b, int ldb, int *jpvt, float rcond, int *rank, int *info);
extern void sgeqlf(int m, int n, float *a, int lda, float *tau, int *info);
extern void sgeqp3(int m, int n, float *a, int lda, int *jpvt, float *tau, int *info);
extern void sgeqpf(int m, int n, float *a, int lda, int *jpivot, float *tau, int *info);
extern void sgeqrf(int m, int n, float *a, int lda, float *tau, int *info);
extern void sgerfs(char transa, int n, int nrhs, float *a, int lda, float *af, int ldaf, int *ipiv, float *b, int ldb, float *x, int ldx, float *ferr, float *berr, int *info);
extern void sgerqf(int m, int n, float *a, int lda, float *tau, int *info);
extern void sgesdd(char jobz, int m, int n, float *a, int lda, float *s, float *u, int ldu, float *vt, int ldvt, int *info);
extern void sgesv(int n, int nrhs, float *a, int lda, int *ipiv, float *b, int ldb, int *info);
extern void sgesvd(char jobu, char jobvt, int m, int n, float *a, int lda, float *sing, float *u, int ldu, float *vt, int ldvt, int *info);

/* N.B. In this C interface to sgesvx, rpvgrw returns what is returned in
   the first element of WORK by the FORTRAN interface */
extern void sgesvx(char fact, char transa, int n, int nrhs, float *a, int lda, float *af, int ldaf, int *ipiv, char equed, float *rowsc, float *colsc, float *b, int ldb, float *x, int ldx, float *rcond, float *ferr, float *berr, float *rpvgrw, int *info);

extern void sgetrf(int m, int n, float *a, int lda, int *ipiv, int *info);
extern void sgetri(int n, float *a, int lda, int *ipiv, int *info);
extern void sgetrs(char transa, int n, int nrhs, float *a, int lda, int *ipiv, float *b, int ldb, int *info);
extern void sggbak(char job, char side, int n, int ilo, int ihi, float *lscale, float *rscale, int m, float *v, int ldv, int *info);
extern void sggbal(char job, int n, float *a, int lda, float *b, int ldb, int *ilo, int *ihi, float *lscale, float *rscale, int *info);
extern void sgges(char jobvsl, char jobvsr, char sort, ACML_SGGES_SELCTG selctg, int n, float *a, int lda, float *b, int ldb, int *sdim, float *alphar, float *alphai, float *beta, float *vsl, int ldvsl, float *vsr, int ldvsr, int *info);
extern void sggesx(char jobvsl, char jobvsr, char sort, ACML_SGGESX_SELCTG selctg, char sense, int n, float *a, int lda, float *b, int ldb, int *sdim, float *alphar, float *alphai, float *beta, float *vsl, int ldvsl, float *vsr, int ldvsr, float *rconde, float *rcondv, int *info);
extern void sggev(char jobvl, char jobvr, int n, float *a, int lda, float *b, int ldb, float *alphar, float *alphai, float *beta, float *vl, int ldvl, float *vr, int ldvr, int *info);
extern void sggevx(char balanc, char jobvl, char jobvr, char sense, int n, float *a, int lda, float *b, int ldb, float *alphar, float *alphai, float *beta, float *vl, int ldvl, float *vr, int ldvr, int *ilo, int *ihi, float *lscale, float *rscale, float *abnrm, float *bbnrm, float *rconde, float *rcondv, int *info);
extern void sggglm(int n, int m, int p, float *a, int lda, float *b, int ldb, float *d, float *x, float *y, int *info);
extern void sgghrd(char compq, char compz, int n, int ilo, int ihi, float *a, int lda, float *b, int ldb, float *q, int ldq, float *z, int ldz, int *info);
extern void sgglse(int m, int n, int p, float *a, int lda, float *b, int ldb, float *c, float *d, float *x, int *info);
extern void sggqrf(int n, int m, int p, float *a, int lda, float *taua, float *b, int ldb, float *taub, int *info);
extern void sggrqf(int m, int p, int n, float *a, int lda, float *taua, float *b, int ldb, float *taub, int *info);
extern void sggsvd(char jobu, char jobv, char jobq, int m, int n, int p, int *k, int *l, float *a, int lda, float *b, int ldb, float *alpha, float *beta, float *u, int ldu, float *v, int ldv, float *q, int ldq, int *iwork3, int *info);
extern void sggsvp(char jobu, char jobv, char jobq, int m, int p, int n, float *a, int lda, float *b, int ldb, float tola, float tolb, int *k, int *l, float *u, int ldu, float *v, int ldv, float *q, int ldq, int *info);
extern void sgtcon(char norm, int n, float *low, float *diag, float *up1, float *up2, int *ipiv, float anorm, float *rcond, int *info);
extern void sgtrfs(char transa, int n, int nrhs, float *low, float *diag, float *up, float *lowf, float *diagf, float *upf1, float *upf2, int *ipiv, float *b, int ldb, float *x, int ldx, float *ferr, float *berr, int *info);
extern void sgtsv(int n, int nrhs, float *low, float *diag, float *up, float *b, int ldb, int *info);
extern void sgtsvx(char fact, char transa, int n, int nrhs, float *low, float *diag, float *up, float *lowf, float *diagf, float *upf1, float *upf2, int *ipiv, float *b, int ldb, float *x, int ldx, float *rcond, float *ferr, float *berr, int *info);
extern void sgttrf(int n, float *low, float *diag, float *up1, float *up2, int *ipiv, int *info);
extern void sgttrs(char transa, int n, int nrhs, float *low, float *diag, float *up1, float *up2, int *ipiv, float *b, int ldb, int *info);
extern void shgeqz(char job, char compq, char compz, int n, int ilo, int ihi, float *a, int lda, float *b, int ldb, float *alphar, float *alphai, float *beta, float *q, int ldq, float *z, int ldz, int *info);
extern void shsein(char side, char eigsrc, char initv, int *select, int n, float *h, int ldh, float *wr, float *wi, float *vl, int ldvl, float *vr, int ldvr, int mm, int *m, int *ifaill, int *ifailr, int *info);
extern void shseqr(char job, char compz, int n, int ilo, int ihi, float *h, int ldh, float *wr, float *wi, float *z, int ldz, int *info);
extern int sisnan(float *sin);
extern float slamch(char cmach);
extern void slasrt(char id, int n, float *d, int *info);
extern void slassq(int n, float *x, int incx, float *scale, float *sumsq);
extern void sopgtr(char uplo, int n, float *ap, float *tau, float *q, int ldq, int *info);
extern void sopmtr(char side, char uplo, char trans, int m, int n, float *ap, float *tau, float *c, int ldc, int *info);
extern void sorgbr(char vect, int m, int n, int k, float *a, int lda, float *tau, int *info);
extern void sorghr(int n, int ilo, int ihi, float *a, int lda, float *tau, int *info);
extern void sorglq(int m, int n, int k, float *a, int lda, float *tau, int *info);
extern void sorgql(int m, int n, int k, float *a, int lda, float *tau, int *info);
extern void sorgqr(int m, int n, int k, float *a, int lda, float *tau, int *info);
extern void sorgrq(int m, int n, int k, float *a, int lda, float *tau, int *info);
extern void sorgtr(char uplo, int n, float *a, int lda, float *tau, int *info);
extern void sormbr(char vect, char side, char trans, int m, int n, int k, float *a, int lda, float *tau, float *c, int ldc, int *info);
extern void sormhr(char side, char trans, int m, int n, int ilo, int ihi, float *a, int lda, float *tau, float *c, int ldc, int *info);
extern void sormlq(char side, char trans, int m, int n, int k, float *a, int lda, float *tau, float *c, int ldc, int *info);
extern void sormql(char side, char trans, int m, int n, int k, float *a, int lda, float *tau, float *c, int ldc, int *info);
extern void sormqr(char side, char trans, int m, int n, int k, float *a, int lda, float *tau, float *c, int ldc, int *info);
extern void sormr3(char side, char trans, int m, int n, int k, int l, float *a, int lda, float *tau, float *c, int ldc, int *info);
extern void sormrq(char side, char trans, int m, int n, int k, float *a, int lda, float *tau, float *c, int ldc, int *info);
extern void sormrz(char side, char trans, int m, int n, int k, int l, float *a, int lda, float *tau, float *c, int ldc, int *info);
extern void sormtr(char side, char uplo, char trans, int m, int n, float *a, int lda, float *tau, float *c, int ldc, int *info);
extern void spbcon(char uplo, int n, int ndiag, float *a, int lda, float anorm, float *rcond, int *info);
extern void spbequ(char uplo, int n, int ndiag, float *a, int lda, float *scale, float *scond, float *amax, int *info);
extern void spbrfs(char uplo, int n, int ndiag, int nrhs, float *a, int lda, float *af, int ldaf, float *b, int ldb, float *x, int ldx, float *ferr, float *berr, int *info);
extern void spbstf(char uplo, int n, int kd, float *ab, int ldab, int *info);
extern void spbsv(char uplo, int n, int ndiag, int nrhs, float *a, int lda, float *b, int ldb, int *info);
extern void spbsvx(char fact, char uplo, int n, int ndiag, int nrhs, float *a, int lda, float *af, int ldaf, char equed, float *scale, float *b, int ldb, float *x, int ldx, float *rcond, float *ferr, float *berr, int *info);
extern void spbtrf(char uplo, int n, int ndiag, float *a, int lda, int *info);
extern void spbtrs(char uplo, int n, int ndiag, int nrhs, float *a, int lda, float *b, int ldb, int *info);
extern void spocon(char uplo, int n, float *a, int lda, float anorm, float *rcond, int *info);
extern void spoequ(int n, float *a, int lda, float *scale, float *scond, float *amax, int *info);
extern void sporfs(char uplo, int n, int nrhs, float *a, int lda, float *af, int ldaf, float *b, int ldb, float *x, int ldx, float *ferr, float *berr, int *info);
extern void sposv(char uplo, int n, int nrhs, float *a, int lda, float *b, int ldb, int *info);
extern void sposvx(char fact, char uplo, int n, int nrhs, float *a, int lda, float *af, int ldaf, char equed, float *scale, float *b, int ldb, float *x, int ldx, float *rcond, float *ferr, float *berr, int *info);
extern void spotrf(char uplo, int n, float *a, int lda, int *info);
extern void spotri(char uplo, int n, float *a, int lda, int *info);
extern void spotrs(char uplo, int n, int nrhs, float *a, int lda, float *b, int ldb, int *info);
extern void sppcon(char uplo, int n, float *a, float anorm, float *rcond, int *info);
extern void sppequ(char uplo, int n, float *a, float *scale, float *scond, float *amax, int *info);
extern void spprfs(char uplo, int n, int nrhs, float *a, float *af, float *b, int ldb, float *x, int ldx, float *ferr, float *berr, int *info);
extern void sppsv(char uplo, int n, int nrhs, float *a, float *b, int ldb, int *info);
extern void sppsvx(char fact, char uplo, int n, int nrhs, float *a, float *af, char equed, float *scale, float *b, int ldb, float *x, int ldx, float *rcond, float *ferr, float *berr, int *info);
extern void spptrf(char uplo, int n, float *a, int *info);
extern void spptri(char uplo, int n, float *a, int *info);
extern void spptrs(char uplo, int n, int nrhs, float *a, float *b, int ldb, int *info);
extern void sptcon(int n, float *diag, float *offd, float anorm, float *rcond, int *info);
extern void spteqr(char compz, int n, float *d, float *e, float *z, int ldz, int *info);
extern void sptrfs(int n, int nrhs, float *diag, float *offd, float *diagf, float *offdf, float *b, int ldb, float *x, int ldx, float *ferr, float *berr, int *info);
extern void sptsv(int n, int nrhs, float *diag, float *sub, float *b, int ldb, int *info);
extern void sptsvx(char fact, int n, int nrhs, float *diag, float *sub, float *diagf, float *subf, float *b, int ldb, float *x, int ldx, float *rcond, float *ferr, float *berr, int *info);
extern void spttrf(int n, float *diag, float *offd, int *info);
extern void spttrs(int n, int nrhs, float *diag, float *offd, float *b, int ldb, int *info);
extern void ssbev(char jobz, char uplo, int n, int ndiag, float *a, int lda, float *w, float *z, int ldz, int *info);
extern void ssbevd(char jobz, char uplo, int n, int kd, float *ab, int ldab, float *w, float *z, int ldz, int *info);
extern void ssbevx(char jobz, char range, char uplo, int n, int ndiag, float *a, int lda, float *q, int ldq, float vl, float vu, int il, int iu, float abtol, int *nfound, float *w, float *z, int ldz, int *ifail, int *info);
extern void ssbgst(char vect, char uplo, int n, int ka, int kb, float *ab, int ldab, float *bb, int ldbb, float *x, int ldx, int *info);
extern void ssbgv(char jobz, char uplo, int n, int ka, int kb, float *ab, int ldab, float *bb, int ldbb, float *w, float *z, int ldz, int *info);
extern void ssbgvd(char jobz, char uplo, int n, int ka, int kb, float *ab, int ldab, float *bb, int ldbb, float *w, float *z, int ldz, int *info);
extern void ssbgvx(char jobz, char range, char uplo, int n, int ka, int kb, float *ab, int ldab, float *bb, int ldbb, float *q, int ldq, float vl, float vu, int il, int iu, float abstol, int *m, float *w, float *z, int ldz, int *ifail, int *info);
extern void ssbtrd(char vect, char uplo, int n, int kd, float *ab, int ldab, float *d, float *e, float *q, int ldq, int *info);
extern void sspcon(char uplo, int n, float *a, int *ipiv, float anorm, float *rcond, int *info);
extern void sspev(char jobz, char uplo, int n, float *a, float *w, float *z, int ldz, int *info);
extern void sspevd(char jobz, char uplo, int n, float *ap, float *w, float *z, int ldz, int *info);
extern void sspevx(char jobz, char range, char uplo, int n, float *a, float vl, float vu, int il, int iu, float abtol, int *nfound, float *w, float *z, int ldz, int *ifail, int *info);
extern void sspgst(int itype, char uplo, int n, float *ap, float *bp, int *info);
extern void sspgv(int itype, char jobz, char uplo, int n, float *a, float *b, float *w, float *z, int ldz, int *info);
extern void sspgvd(int itype, char jobz, char uplo, int n, float *ap, float *bp, float *w, float *z, int ldz, int *info);
extern void sspgvx(int itype, char jobz, char range, char uplo, int n, float *ap, float *bp, float vl, float vu, int il, int iu, float abstol, int *m, float *w, float *z, int ldz, int *ifail, int *info);
extern void ssprfs(char uplo, int n, int nrhs, float *a, float *af, int *ipiv, float *b, int ldb, float *x, int ldx, float *ferr, float *berr, int *info);
extern void sspsv(char uplo, int n, int nrhs, float *a, int *ipiv, float *b, int ldb, int *info);
extern void sspsvx(char fact, char uplo, int n, int nrhs, float *a, float *af, int *ipiv, float *b, int ldb, float *x, int ldx, float *rcond, float *ferr, float *berr, int *info);
extern void ssptrd(char uplo, int n, float *ap, float *d, float *e, float *tau, int *info);
extern void ssptrf(char uplo, int n, float *a, int *ipiv, int *info);
extern void ssptri(char uplo, int n, float *a, int *ipiv, int *info);
extern void ssptrs(char uplo, int n, int nrhs, float *a, int *ipiv, float *b, int ldb, int *info);
extern void sstebz(char range, char order, int n, float vl, float vu, int il, int iu, float abstol, float *d, float *e, int *m, int *nsplit, float *w, int *iblock, int *isplit, int *info);
extern void sstedc(char compz, int n, float *d, float *e, float *z, int ldz, int *info);
extern void sstegr(char jobz, char range, int n, float *d, float *e, float vl, float vu, int il, int iu, float abstol, int *m, float *w, float *z, int ldz, int *isuppz, int *info);
extern void sstein(int n, float *d, float *e, int m, float *w, int *iblock, int *isplit, float *z, int ldz, int *ifail, int *info);
extern void ssteqr(char compz, int n, float *d, float *e, float *z, int ldz, int *info);
extern void ssterf(int n, float *d, float *e, int *info);
extern void sstev(char jobz, int n, float *diag, float *offd, float *z, int ldz, int *info);
extern void sstevd(char jobz, int n, float *d, float *e, float *z, int ldz, int *info);
extern void sstevr(char jobz, char range, int n, float *d, float *e, float vl, float vu, int il, int iu, float abstol, int *m, float *w, float *z, int ldz, int *isuppz, int *info);
extern void sstevx(char jobz, char range, int n, float *diag, float *offd, float vl, float vu, int il, int iu, float abtol, int *nfound, float *w, float *z, int ldz, int *ifail, int *info);
extern void ssycon(char uplo, int n, float *a, int lda, int *ipiv, float anorm, float *rcond, int *info);
extern void ssyev(char jobz, char uplo, int n, float *a, int lda, float *w, int *info);
extern void ssyevd(char jobz, char uplo, int n, float *a, int lda, float *w, int *info);
extern void ssyevr(char jobz, char range, char uplo, int n, float *a, int lda, float vl, float vu, int il, int iu, float abstol, int *m, float *w, float *z, int ldz, int *isuppz, int *info);
extern void ssyevx(char jobz, char range, char uplo, int n, float *a, int lda, float vl, float vu, int il, int iu, float abtol, int *nfound, float *w, float *z, int ldz, int *ifail, int *info);
extern void ssygst(int itype, char uplo, int n, float *a, int lda, float *b, int ldb, int *info);
extern void ssygv(int itype, char jobz, char uplo, int n, float *a, int lda, float *b, int ldb, float *w, int *info);
extern void ssygvd(int itype, char jobz, char uplo, int n, float *a, int lda, float *b, int ldb, float *w, int *info);
extern void ssygvx(int itype, char jobz, char range, char uplo, int n, float *a, int lda, float *b, int ldb, float vl, float vu, int il, int iu, float abstol, int *m, float *w, float *z, int ldz, int *ifail, int *info);
extern void ssyrfs(char uplo, int n, int nrhs, float *a, int lda, float *af, int ldaf, int *ipiv, float *b, int ldb, float *x, int ldx, float *ferr, float *berr, int *info);
extern void ssysv(char uplo, int n, int nrhs, float *a, int lda, int *ipiv, float *b, int ldb, int *info);
extern void ssysvx(char fact, char uplo, int n, int nrhs, float *a, int lda, float *af, int ldaf, int *ipiv, float *b, int ldb, float *x, int ldx, float *rcond, float *ferr, float *berr, int *info);
extern void ssytrd(char uplo, int n, float *a, int lda, float *d, float *e, float *tau, int *info);
extern void ssytrf(char uplo, int n, float *a, int lda, int *ipiv, int *info);
extern void ssytri(char uplo, int n, float *a, int lda, int *ipiv, int *info);
extern void ssytrs(char uplo, int n, int nrhs, float *a, int lda, int *ipiv, float *b, int ldb, int *info);
extern void stbcon(char norm, char uplo, char diag, int n, int ndiag, float *a, int lda, float *rcond, int *info);
extern void stbrfs(char uplo, char transa, char diag, int n, int ndiag, int nrhs, float *a, int lda, float *b, int ldb, float *x, int ldx, float *ferr, float *berr, int *info);
extern void stbtrs(char uplo, char transa, char diag, int n, int ndiag, int nrhs, float *a, int lda, float *b, int ldb, int *info);
extern void stgevc(char side, char howmny, int *select, int n, float *a, int lda, float *b, int ldb, float *vl, int ldvl, float *vr, int ldvr, int mm, int *m, int *info);
extern void stgexc(int wantq, int wantz, int n, float *a, int lda, float *b, int ldb, float *q, int ldq, float *z, int ldz, int *ifst, int *ilst, int *info);
extern void stgsen(int ijob, int wantq, int wantz, int *select, int n, float *a, int lda, float *b, int ldb, float *alphar, float *alphai, float *beta, float *q, int ldq, float *z, int ldz, int *m, float *pl, float *pr, float *dif, int *info);
extern void stgsja(char jobu, char jobv, char jobq, int m, int p, int n, int k, int l, float *a, int lda, float *b, int ldb, float tola, float tolb, float *alpha, float *beta, float *u, int ldu, float *v, int ldv, float *q, int ldq, int *ncycle, int *info);
extern void stgsna(char job, char howmnt, int *select, int n, float *a, int lda, float *b, int ldb, float *vl, int ldvl, float *vr, int ldvr, float *s, float *dif, int mm, int *m, int *info);
extern void stgsyl(char trans, int ijob, int m, int n, float *a, int lda, float *b, int ldb, float *c, int ldc, float *d, int ldd, float *e, int lde, float *f, int ldf, float *scale, float *dif, int *info);
extern void stpcon(char norm, char uplo, char diag, int n, float *a, float *rcond, int *info);
extern void stprfs(char uplo, char transa, char diag, int n, int nrhs, float *a, float *b, int ldb, float *x, int ldx, float *ferr, float *berr, int *info);
extern void stptri(char uplo, char diag, int n, float *a, int *info);
extern void stptrs(char uplo, char transa, char diag, int n, int nrhs, float *a, float *b, int ldb, int *info);
extern void strcon(char norm, char uplo, char diag, int n, float *a, int lda, float *rcond, int *info);
extern void strevc(char side, char howmny, int *select, int n, float *t, int ldt, float *vl, int ldvl, float *vr, int ldvr, int mm, int *m, int *info);
extern void strexc(char compq, int n, float *t, int ldt, float *q, int ldq, int *ifst, int *ilst, int *info);
extern void strrfs(char uplo, char transa, char diag, int n, int nrhs, float *a, int lda, float *b, int ldb, float *x, int ldx, float *ferr, float *berr, int *info);
extern void strsen(char job, char compq, int *select, int n, float *t, int ldt, float *q, int ldq, float *wr, float *wi, int *m, float *s, float *sep, int *info);
extern void strsna(char job, char howmny, int *select, int n, float *t, int ldt, float *vl, int ldvl, float *vr, int ldvr, float *s, float *sep, int mm, int *m, int *info);
extern void strsyl(char trana, char tranb, int isgn, int m, int n, float *a, int lda, float *b, int ldb, float *c, int ldc, float *scale, int *info);
extern void strtri(char uplo, char diag, int n, float *a, int lda, int *info);
extern void strtrs(char uplo, char transa, char diag, int n, int nrhs, float *a, int lda, float *b, int ldb, int *info);
extern void stzrqf(int m, int n, float *a, int lda, float *tau, int *info);
extern void stzrzf(int m, int n, float *a, int lda, float *tau, int *info);
extern void zbdsqr(char uplo, int n, int ncvt, int nru, int ncc, double *d, double *e, doublecomplex *vt, int ldvt, doublecomplex *u, int ldu, doublecomplex *c, int ldc, int *info);
extern void zcgesv(int n, int nrhs, doublecomplex *a, int lda, int *ipiv, doublecomplex *b, int ldb, doublecomplex *x, int ldx, doublecomplex *work, complex *swork, int *iter, int *info);
extern void zgbbrd(char vect, int m, int n, int ncc, int kl, int ku, doublecomplex *ab, int ldab, double *d, double *e, doublecomplex *q, int ldq, doublecomplex *pt, int ldpt, doublecomplex *c, int ldc, int *info);
extern void zgbcon(char norm, int n, int nsub, int nsuper, doublecomplex *a, int lda, int *ipiv, double anorm, double *rcond, int *info);
extern void zgbequ(int m, int n, int nsub, int nsuper, doublecomplex *a, int lda, double *rowsc, double *colsc, double *rowcn, double *colcn, double *amax, int *info);
extern void zgbrfs(char transa, int n, int nsub, int nsuper, int nrhs, doublecomplex *a, int lda, doublecomplex *af, int ldaf, int *ipiv, doublecomplex *b, int ldb, doublecomplex *x, int ldx, double *ferr, double *berr, int *info);
extern void zgbsv(int n, int nsub, int nsuper, int nrhs, doublecomplex *a, int lda, int *ipiv, doublecomplex *b, int ldb, int *info);

/* N.B. In this C interface to zgbsvx, rpvgrw returns what is returned in
   the first element of RWORK by the FORTRAN interface */
extern void zgbsvx(char fact, char transa, int n, int nsub, int nsuper, int nrhs, doublecomplex *a, int lda, doublecomplex *af, int ldaf, int *ipiv, char equed, double *rowsc, double *colsc, doublecomplex *b, int ldb, doublecomplex *x, int ldx, double *rcond, double *ferr, double *berr, double *rpvgrw, int *info);

extern void zgbtrf(int m, int n, int nsub, int nsuper, doublecomplex *a, int lda, int *ipiv, int *info);
extern void zgbtrs(char transa, int n, int nsub, int nsuper, int nrhs, doublecomplex *a, int lda, int *ipiv, doublecomplex *b, int ldb, int *info);
extern void zgebak(char job, char side, int n, int ilo, int ihi, double *scale, int m, doublecomplex *v, int ldv, int *info);
extern void zgebal(char job, int n, doublecomplex *a, int lda, int *ilo, int *ihi, double *scale, int *info);
extern void zgebrd(int m, int n, doublecomplex *a, int lda, double *d, double *e, doublecomplex *tauq, doublecomplex *taup, int *info);
extern void zgecon(char norm, int n, doublecomplex *a, int lda, double anorm, double *rcond, int *info);
extern void zgeequ(int m, int n, doublecomplex *a, int lda, double *rowsc, double *colsc, double *rowcn, double *colcn, double *amax, int *info);
extern void zgees(char jobvs, char sort, ACML_ZGEES_SELECT select, int n, doublecomplex *a, int lda, int *sdim, doublecomplex *w, doublecomplex *vs, int ldvs, int *info);
extern void zgeesx(char jobvs, char sort, ACML_ZGEESX_SELECT select, char sense, int n, doublecomplex *a, int lda, int *sdim, doublecomplex *w, doublecomplex *vs, int ldvs, double *rconde, double *rcondv, int *info);
extern void zgeev(char jobvl, char jobvr, int n, doublecomplex *a, int lda, doublecomplex *w, doublecomplex *vl, int ldvl, doublecomplex *vr, int ldvr, int *info);
extern void zgeevx(char balanc, char jobvl, char jobvr, char sense, int n, doublecomplex *a, int lda, doublecomplex *w, doublecomplex *vl, int ldvl, doublecomplex *vr, int ldvr, int *ilo, int *ihi, double *scale, double *abnrm, double *rconde, double *rcondv, int *info);
extern void zgegs(char jobvsl, char jobvsr, int n, doublecomplex *a, int lda, doublecomplex *b, int ldb, doublecomplex *alpha, doublecomplex *beta, doublecomplex *vsl, int ldvsl, doublecomplex *vsr, int ldvsr, int *info);
extern void zgegv(char jobvl, char jobvr, int n, doublecomplex *a, int lda, doublecomplex *b, int ldb, doublecomplex *alpha, doublecomplex *beta, doublecomplex *vl, int ldvl, doublecomplex *vr, int ldvr, int *info);
extern void zgehrd(int n, int ilo, int ihi, doublecomplex *a, int lda, doublecomplex *tau, int *info);
extern void zgelqf(int m, int n, doublecomplex *a, int lda, doublecomplex *tau, int *info);
extern void zgels(char trans, int m, int n, int nrhs, doublecomplex *a, int lda, doublecomplex *b, int ldb, int *info);
extern void zgelsd(int m, int n, int nrhs, doublecomplex *a, int lda, doublecomplex *b, int ldb, double *s, double rcond, int *rank, int *info);
extern void zgelss(int m, int n, int nrhs, doublecomplex *a, int lda, doublecomplex *b, int ldb, double *sing, double rcond, int *irank, int *info);
extern void zgelsx(int m, int n, int nrhs, doublecomplex *a, int lda, doublecomplex *b, int ldb, int *jpivot, double rcond, int *irank, int *info);
extern void zgelsy(int m, int n, int nrhs, doublecomplex *a, int lda, doublecomplex *b, int ldb, int *jpvt, double rcond, int *rank, int *info);
extern void zgeqlf(int m, int n, doublecomplex *a, int lda, doublecomplex *tau, int *info);
extern void zgeqp3(int m, int n, doublecomplex *a, int lda, int *jpvt, doublecomplex *tau, int *info);
extern void zgeqpf(int m, int n, doublecomplex *a, int lda, int *jpvt, doublecomplex *tau, int *info);
extern void zgeqrf(int m, int n, doublecomplex *a, int lda, doublecomplex *tau, int *info);
extern void zgerfs(char transa, int n, int nrhs, doublecomplex *a, int lda, doublecomplex *af, int ldaf, int *ipiv, doublecomplex *b, int ldb, doublecomplex *x, int ldx, double *ferr, double *berr, int *info);
extern void zgerqf(int m, int n, doublecomplex *a, int lda, doublecomplex *tau, int *info);
extern void zgesdd(char jobz, int m, int n, doublecomplex *a, int lda, double *s, doublecomplex *u, int ldu, doublecomplex *vt, int ldvt, int *info);
extern void zgesv(int n, int nrhs, doublecomplex *a, int lda, int *ipiv, doublecomplex *b, int ldb, int *info);
extern void zgesvd(char jobu, char jobvt, int m, int n, doublecomplex *a, int lda, double *sing, doublecomplex *u, int ldu, doublecomplex *vt, int ldvt, int *info);

/* N.B. In this C interface to zgesvx, rpvgrw returns what is returned in
   the first element of RWORK by the FORTRAN interface */
extern void zgesvx(char fact, char transa, int n, int nrhs, doublecomplex *a, int lda, doublecomplex *af, int ldaf, int *ipiv, char equed, double *rowsc, double *colsc, doublecomplex *b, int ldb, doublecomplex *x, int ldx, double *rcond, double *ferr, double *berr, double *rpvgrw, int *info);

extern void zgetrf(int m, int n, doublecomplex *a, int lda, int *ipiv, int *info);
extern void zgetri(int n, doublecomplex *a, int lda, int *ipiv, int *info);
extern void zgetrs(char transa, int n, int nrhs, doublecomplex *a, int lda, int *ipiv, doublecomplex *b, int ldb, int *info);
extern void zggbak(char job, char side, int n, int ilo, int ihi, double *lscale, double *rscale, int m, doublecomplex *v, int ldv, int *info);
extern void zggbal(char job, int n, doublecomplex *a, int lda, doublecomplex *b, int ldb, int *ilo, int *ihi, double *lscale, double *rscale, int *info);
extern void zgges(char jobvsl, char jobvsr, char sort, ACML_ZGGES_DELCTG delctg, int n, doublecomplex *a, int lda, doublecomplex *b, int ldb, int *sdim, doublecomplex *alpha, doublecomplex *beta, doublecomplex *vsl, int ldvsl, doublecomplex *vsr, int ldvsr, int *info);
extern void zggesx(char jobvsl, char jobvsr, char sort, ACML_ZGGESX_DELCTG delctg, char sense, int n, doublecomplex *a, int lda, doublecomplex *b, int ldb, int *sdim, doublecomplex *alpha, doublecomplex *beta, doublecomplex *vsl, int ldvsl, doublecomplex *vsr, int ldvsr, double *rconde, double *rcondv, int *info);
extern void zggev(char jobvl, char jobvr, int n, doublecomplex *a, int lda, doublecomplex *b, int ldb, doublecomplex *alpha, doublecomplex *beta, doublecomplex *vl, int ldvl, doublecomplex *vr, int ldvr, int *info);
extern void zggevx(char balanc, char jobvl, char jobvr, char sense, int n, doublecomplex *a, int lda, doublecomplex *b, int ldb, doublecomplex *alpha, doublecomplex *beta, doublecomplex *vl, int ldvl, doublecomplex *vr, int ldvr, int *ilo, int *ihi, double *lscale, double *rscale, double *abnrm, double *bbnrm, double *rconde, double *rcondv, int *info);
extern void zggglm(int n, int m, int p, doublecomplex *a, int lda, doublecomplex *b, int ldb, doublecomplex *d, doublecomplex *x, doublecomplex *y, int *info);
extern void zgghrd(char compq, char compz, int n, int ilo, int ihi, doublecomplex *a, int lda, doublecomplex *b, int ldb, doublecomplex *q, int ldq, doublecomplex *z, int ldz, int *info);
extern void zgglse(int m, int n, int p, doublecomplex *a, int lda, doublecomplex *b, int ldb, doublecomplex *c, doublecomplex *d, doublecomplex *x, int *info);
extern void zggqrf(int n, int m, int p, doublecomplex *a, int lda, doublecomplex *taua, doublecomplex *b, int ldb, doublecomplex *taub, int *info);
extern void zggrqf(int m, int p, int n, doublecomplex *a, int lda, doublecomplex *taua, doublecomplex *b, int ldb, doublecomplex *taub, int *info);
extern void zggsvd(char jobu, char jobv, char jobq, int m, int n, int p, int *k, int *l, doublecomplex *a, int lda, doublecomplex *b, int ldb, double *alpha, double *beta, doublecomplex *u, int ldu, doublecomplex *v, int ldv, doublecomplex *q, int ldq, int *iwork3, int *info);
extern void zggsvp(char jobu, char jobv, char jobq, int m, int p, int n, doublecomplex *a, int lda, doublecomplex *b, int ldb, double tola, double tolb, int *k, int *l, doublecomplex *u, int ldu, doublecomplex *v, int ldv, doublecomplex *q, int ldq, int *info);
extern void zgtcon(char norm, int n, doublecomplex *low, doublecomplex *diag, doublecomplex *up1, doublecomplex *up2, int *ipiv, double anorm, double *rcond, int *info);
extern void zgtrfs(char transa, int n, int nrhs, doublecomplex *low, doublecomplex *diag, doublecomplex *up, doublecomplex *lowf, doublecomplex *diagf, doublecomplex *upf1, doublecomplex *upf2, int *ipiv, doublecomplex *b, int ldb, doublecomplex *x, int ldx, double *ferr, double *berr, int *info);
extern void zgtsv(int n, int nrhs, doublecomplex *low, doublecomplex *diag, doublecomplex *up, doublecomplex *b, int ldb, int *info);
extern void zgtsvx(char fact, char transa, int n, int nrhs, doublecomplex *low, doublecomplex *diag, doublecomplex *up, doublecomplex *lowf, doublecomplex *diagf, doublecomplex *upf1, doublecomplex *upf2, int *ipiv, doublecomplex *b, int ldb, doublecomplex *x, int ldx, double *rcond, double *ferr, double *berr, int *info);
extern void zgttrf(int n, doublecomplex *low, doublecomplex *diag, doublecomplex *up1, doublecomplex *up2, int *ipiv, int *info);
extern void zgttrs(char transa, int n, int nrhs, doublecomplex *low, doublecomplex *diag, doublecomplex *up1, doublecomplex *up2, int *ipiv, doublecomplex *b, int ldb, int *info);
extern void zhbev(char jobz, char uplo, int n, int ndiag, doublecomplex *a, int lda, double *w, doublecomplex *z, int ldz, int *info);
extern void zhbevd(char jobz, char uplo, int n, int kd, doublecomplex *ab, int ldab, double *w, doublecomplex *z, int ldz, int *info);
extern void zhbevx(char jobz, char range, char uplo, int n, int ndiag, doublecomplex *a, int lda, doublecomplex *q, int ldq, double vl, double vu, int il, int iu, double abtol, int *nfound, double *w, doublecomplex *z, int ldz, int *ifail, int *info);
extern void zhbgst(char vect, char uplo, int n, int ka, int kb, doublecomplex *ab, int ldab, doublecomplex *bb, int ldbb, doublecomplex *x, int ldx, int *info);
extern void zhbgv(char jobz, char uplo, int n, int ka, int kb, doublecomplex *ab, int ldab, doublecomplex *bb, int ldbb, double *w, doublecomplex *z, int ldz, int *info);
extern void zhbgvd(char jobz, char uplo, int n, int ka, int kb, doublecomplex *ab, int ldab, doublecomplex *bb, int ldbb, double *w, doublecomplex *z, int ldz, int *info);
extern void zhbgvx(char jobz, char range, char uplo, int n, int ka, int kb, doublecomplex *ab, int ldab, doublecomplex *bb, int ldbb, doublecomplex *q, int ldq, double vl, double vu, int il, int iu, double abstol, int *m, double *w, doublecomplex *z, int ldz, int *ifail, int *info);
extern void zhbtrd(char vect, char uplo, int n, int kd, doublecomplex *ab, int ldab, double *d, double *e, doublecomplex *q, int ldq, int *info);
extern void zhecon(char uplo, int n, doublecomplex *a, int lda, int *ipiv, double anorm, double *rcond, int *info);
extern void zheev(char jobz, char uplo, int n, doublecomplex *a, int lda, double *w, int *info);
extern void zheevd(char jobz, char uplo, int n, doublecomplex *a, int lda, double *w, int *info);
extern void zheevr(char jobz, char range, char uplo, int n, doublecomplex *a, int lda, double vl, double vu, int il, int iu, double abstol, int *m, double *w, doublecomplex *z, int ldz, int *isuppz, int *info);
extern void zheevx(char jobz, char range, char uplo, int n, doublecomplex *a, int lda, double vl, double vu, int il, int iu, double abtol, int *nfound, double *w, doublecomplex *z, int ldz, int *ifail, int *info);
extern void zhegst(int itype, char uplo, int n, doublecomplex *a, int lda, doublecomplex *b, int ldb, int *info);
extern void zhegv(int itype, char jobz, char uplo, int n, doublecomplex *a, int lda, doublecomplex *b, int ldb, double *w, int *info);
extern void zhegvd(int itype, char jobz, char uplo, int n, doublecomplex *a, int lda, doublecomplex *b, int ldb, double *w, int *info);
extern void zhegvx(int itype, char jobz, char range, char uplo, int n, doublecomplex *a, int lda, doublecomplex *b, int ldb, double vl, double vu, int il, int iu, double abstol, int *m, double *w, doublecomplex *z, int ldz, int *ifail, int *info);
extern void zherfs(char uplo, int n, int nrhs, doublecomplex *a, int lda, doublecomplex *af, int ldaf, int *ipiv, doublecomplex *b, int ldb, doublecomplex *x, int ldx, double *ferr, double *berr, int *info);
extern void zhesv(char uplo, int n, int nrhs, doublecomplex *a, int lda, int *ipiv, doublecomplex *b, int ldb, int *info);
extern void zhesvx(char fact, char uplo, int n, int nrhs, doublecomplex *a, int lda, doublecomplex *af, int ldaf, int *ipiv, doublecomplex *b, int ldb, doublecomplex *x, int ldx, double *rcond, double *ferr, double *berr, int *info);
extern void zhetrd(char uplo, int n, doublecomplex *a, int lda, double *d, double *e, doublecomplex *tau, int *info);
extern void zhetrf(char uplo, int n, doublecomplex *a, int lda, int *ipiv, int *info);
extern void zhetri(char uplo, int n, doublecomplex *a, int lda, int *ipiv, int *info);
extern void zhetrs(char uplo, int n, int nrhs, doublecomplex *a, int lda, int *ipiv, doublecomplex *b, int ldb, int *info);
extern void zhgeqz(char job, char compq, char compz, int n, int ilo, int ihi, doublecomplex *a, int lda, doublecomplex *b, int ldb, doublecomplex *alpha, doublecomplex *beta, doublecomplex *q, int ldq, doublecomplex *z, int ldz, int *info);
extern void zhpcon(char uplo, int n, doublecomplex *a, int *ipiv, double anorm, double *rcond, int *info);
extern void zhpev(char jobz, char uplo, int n, doublecomplex *a, double *w, doublecomplex *z, int ldz, int *info);
extern void zhpevd(char jobz, char uplo, int n, doublecomplex *ap, double *w, doublecomplex *z, int ldz, int *info);
extern void zhpevx(char jobz, char range, char uplo, int n, doublecomplex *a, double vl, double vu, int il, int iu, double abtol, int *nfound, double *w, doublecomplex *z, int ldz, int *ifail, int *info);
extern void zhpgst(int itype, char uplo, int n, doublecomplex *ap, doublecomplex *bp, int *info);
extern void zhpgv(int itype, char jobz, char uplo, int n, doublecomplex *a, doublecomplex *b, double *w, doublecomplex *z, int ldz, int *info);
extern void zhpgvd(int itype, char jobz, char uplo, int n, doublecomplex *ap, doublecomplex *bp, double *w, doublecomplex *z, int ldz, int *info);
extern void zhpgvx(int itype, char jobz, char range, char uplo, int n, doublecomplex *ap, doublecomplex *bp, double vl, double vu, int il, int iu, double abstol, int *m, double *w, doublecomplex *z, int ldz, int *ifail, int *info);
extern void zhprfs(char uplo, int n, int nrhs, doublecomplex *a, doublecomplex *af, int *ipiv, doublecomplex *b, int ldb, doublecomplex *x, int ldx, double *ferr, double *berr, int *info);
extern void zhpsv(char uplo, int n, int nrhs, doublecomplex *a, int *ipiv, doublecomplex *b, int ldb, int *info);
extern void zhpsvx(char fact, char uplo, int n, int nrhs, doublecomplex *a, doublecomplex *af, int *ipiv, doublecomplex *b, int ldb, doublecomplex *x, int ldx, double *rcond, double *ferr, double *berr, int *info);
extern void zhptrd(char uplo, int n, doublecomplex *ap, double *d, double *e, doublecomplex *tau, int *info);
extern void zhptrf(char uplo, int n, doublecomplex *a, int *ipiv, int *info);
extern void zhptri(char uplo, int n, doublecomplex *a, int *ipiv, int *info);
extern void zhptrs(char uplo, int n, int nrhs, doublecomplex *a, int *ipiv, doublecomplex *b, int ldb, int *info);
extern void zhsein(char side, char eigsrc, char initv, int *select, int n, doublecomplex *h, int ldh, doublecomplex *w, doublecomplex *vl, int ldvl, doublecomplex *vr, int ldvr, int mm, int *m, int *ifaill, int *ifailr, int *info);
extern void zhseqr(char job, char compz, int n, int ilo, int ihi, doublecomplex *h, int ldh, doublecomplex *w, doublecomplex *z, int ldz, int *info);
extern void zpbcon(char uplo, int n, int ndiag, doublecomplex *a, int lda, double anorm, double *rcond, int *info);
extern void zpbequ(char uplo, int n, int ndiag, doublecomplex *a, int lda, double *scale, double *scond, double *amax, int *info);
extern void zpbrfs(char uplo, int n, int ndiag, int nrhs, doublecomplex *a, int lda, doublecomplex *af, int ldaf, doublecomplex *b, int ldb, doublecomplex *x, int ldx, double *ferr, double *berr, int *info);
extern void zpbstf(char uplo, int n, int kd, doublecomplex *ab, int ldab, int *info);
extern void zpbsv(char uplo, int n, int ndiag, int nrhs, doublecomplex *a, int lda, doublecomplex *b, int ldb, int *info);
extern void zpbsvx(char fact, char uplo, int n, int ndiag, int nrhs, doublecomplex *a, int lda, doublecomplex *af, int ldaf, char equed, double *scale, doublecomplex *b, int ldb, doublecomplex *x, int ldx, double *rcond, double *ferr, double *berr, int *info);
extern void zpbtrf(char uplo, int n, int ndiag, doublecomplex *a, int lda, int *info);
extern void zpbtrs(char uplo, int n, int ndiag, int nrhs, doublecomplex *a, int lda, doublecomplex *b, int ldb, int *info);
extern void zpocon(char uplo, int n, doublecomplex *a, int lda, double anorm, double *rcond, int *info);
extern void zpoequ(int n, doublecomplex *a, int lda, double *scale, double *scond, double *amax, int *info);
extern void zporfs(char uplo, int n, int nrhs, doublecomplex *a, int lda, doublecomplex *af, int ldaf, doublecomplex *b, int ldb, doublecomplex *x, int ldx, double *ferr, double *berr, int *info);
extern void zposv(char uplo, int n, int nrhs, doublecomplex *a, int lda, doublecomplex *b, int ldb, int *info);
extern void zposvx(char fact, char uplo, int n, int nrhs, doublecomplex *a, int lda, doublecomplex *af, int ldaf, char equed, double *scale, doublecomplex *b, int ldb, doublecomplex *x, int ldx, double *rcond, double *ferr, double *berr, int *info);
extern void zpotrf(char uplo, int n, doublecomplex *a, int lda, int *info);
extern void zpotri(char uplo, int n, doublecomplex *a, int lda, int *info);
extern void zpotrs(char uplo, int n, int nrhs, doublecomplex *a, int lda, doublecomplex *b, int ldb, int *info);
extern void zppcon(char uplo, int n, doublecomplex *a, double anorm, double *rcond, int *info);
extern void zppequ(char uplo, int n, doublecomplex *a, double *scale, double *scond, double *amax, int *info);
extern void zpprfs(char uplo, int n, int nrhs, doublecomplex *a, doublecomplex *af, doublecomplex *b, int ldb, doublecomplex *x, int ldx, double *ferr, double *berr, int *info);
extern void zppsv(char uplo, int n, int nrhs, doublecomplex *a, doublecomplex *b, int ldb, int *info);
extern void zppsvx(char fact, char uplo, int n, int nrhs, doublecomplex *a, doublecomplex *af, char equed, double *scale, doublecomplex *b, int ldb, doublecomplex *x, int ldx, double *rcond, double *ferr, double *berr, int *info);
extern void zpptrf(char uplo, int n, doublecomplex *a, int *info);
extern void zpptri(char uplo, int n, doublecomplex *a, int *info);
extern void zpptrs(char uplo, int n, int nrhs, doublecomplex *a, doublecomplex *b, int ldb, int *info);
extern void zptcon(int n, double *diag, doublecomplex *offd, double anorm, double *rcond, int *info);
extern void zpteqr(char compz, int n, double *d, double *e, doublecomplex *z, int ldz, int *info);
extern void zptrfs(char uplo, int n, int nrhs, double *diag, doublecomplex *offd, double *diagf, doublecomplex *offdf, doublecomplex *b, int ldb, doublecomplex *x, int ldx, double *ferr, double *berr, int *info);
extern void zptsv(int n, int nrhs, double *diag, doublecomplex *sub, doublecomplex *b, int ldb, int *info);
extern void zptsvx(char fact, int n, int nrhs, double *diag, doublecomplex *sub, double *diagf, doublecomplex *subf, doublecomplex *b, int ldb, doublecomplex *x, int ldx, double *rcond, double *ferr, double *berr, int *info);
extern void zpttrf(int n, double *diag, doublecomplex *offd, int *info);
extern void zpttrs(char uplo, int n, int nrhs, double *diag, doublecomplex *offd, doublecomplex *b, int ldb, int *info);
extern void zspcon(char uplo, int n, doublecomplex *a, int *ipiv, double anorm, double *rcond, int *info);
extern void zsprfs(char uplo, int n, int nrhs, doublecomplex *a, doublecomplex *af, int *ipiv, doublecomplex *b, int ldb, doublecomplex *x, int ldx, double *ferr, double *berr, int *info);
extern void zspsv(char uplo, int n, int nrhs, doublecomplex *a, int *ipiv, doublecomplex *b, int ldb, int *info);
extern void zspsvx(char fact, char uplo, int n, int nrhs, doublecomplex *a, doublecomplex *af, int *ipiv, doublecomplex *b, int ldb, doublecomplex *x, int ldx, double *rcond, double *ferr, double *berr, int *info);
extern void zsptrf(char uplo, int n, doublecomplex *a, int *ipiv, int *info);
extern void zsptri(char uplo, int n, doublecomplex *a, int *ipiv, int *info);
extern void zsptrs(char uplo, int n, int nrhs, doublecomplex *a, int *ipiv, doublecomplex *b, int ldb, int *info);
extern void zstedc(char compz, int n, double *d, double *e, doublecomplex *z, int ldz, int *info);
extern void zstegr(char jobz, char range, int n, double *d, double *e, double vl, double vu, int il, int iu, double abstol, int *m, double *w, doublecomplex *z, int ldz, int *isuppz, int *info);
extern void zstein(int n, double *d, double *e, int m, double *w, int *iblock, int *isplit, doublecomplex *z, int ldz, int *ifail, int *info);
extern void zsteqr(char compz, int n, double *d, double *e, doublecomplex *z, int ldz, int *info);
extern void zsycon(char uplo, int n, doublecomplex *a, int lda, int *ipiv, double anorm, double *rcond, int *info);
extern void zsyrfs(char uplo, int n, int nrhs, doublecomplex *a, int lda, doublecomplex *af, int ldaf, int *ipiv, doublecomplex *b, int ldb, doublecomplex *x, int ldx, double *ferr, double *berr, int *info);
extern void zsysv(char uplo, int n, int nrhs, doublecomplex *a, int lda, int *ipiv, doublecomplex *b, int ldb, int *info);
extern void zsysvx(char fact, char uplo, int n, int nrhs, doublecomplex *a, int lda, doublecomplex *af, int ldaf, int *ipiv, doublecomplex *b, int ldb, doublecomplex *x, int ldx, double *rcond, double *ferr, double *berr, int *info);
extern void zsytrf(char uplo, int n, doublecomplex *a, int lda, int *ipiv, int *info);
extern void zsytri(char uplo, int n, doublecomplex *a, int lda, int *ipiv, int *info);
extern void zsytrs(char uplo, int n, int nrhs, doublecomplex *a, int lda, int *ipiv, doublecomplex *b, int ldb, int *info);
extern void ztbcon(char norm, char uplo, char diag, int n, int ndiag, doublecomplex *a, int lda, double *rcond, int *info);
extern void ztbrfs(char uplo, char transa, char diag, int n, int ndiag, int nrhs, doublecomplex *a, int lda, doublecomplex *b, int ldb, doublecomplex *x, int ldx, double *ferr, double *berr, int *info);
extern void ztbtrs(char uplo, char transa, char diag, int n, int ndiag, int nrhs, doublecomplex *a, int lda, doublecomplex *b, int ldb, int *info);
extern void ztgevc(char side, char howmny, int *select, int n, doublecomplex *a, int lda, doublecomplex *b, int ldb, doublecomplex *vl, int ldvl, doublecomplex *vr, int ldvr, int mm, int *m, int *info);
extern void ztgexc(int wantq, int wantz, int n, doublecomplex *a, int lda, doublecomplex *b, int ldb, doublecomplex *q, int ldq, doublecomplex *z, int ldz, int *ifst, int *ilst, int *info);
extern void ztgsen(int ijob, int wantq, int wantz, int *select, int n, doublecomplex *a, int lda, doublecomplex *b, int ldb, doublecomplex *alpha, doublecomplex *beta, doublecomplex *q, int ldq, doublecomplex *z, int ldz, int *m, double *pl, double *pr, double *dif, int *info);
extern void ztgsja(char jobu, char jobv, char jobq, int m, int p, int n, int k, int l, doublecomplex *a, int lda, doublecomplex *b, int ldb, double tola, double tolb, double *alpha, double *beta, doublecomplex *u, int ldu, doublecomplex *v, int ldv, doublecomplex *q, int ldq, int *ncycle, int *info);
extern void ztgsna(char job, char howmnt, int *select, int n, doublecomplex *a, int lda, doublecomplex *b, int ldb, doublecomplex *vl, int ldvl, doublecomplex *vr, int ldvr, double *s, double *dif, int mm, int *m, int *info);
extern void ztgsyl(char trans, int ijob, int m, int n, doublecomplex *a, int lda, doublecomplex *b, int ldb, doublecomplex *c, int ldc, doublecomplex *d, int ldd, doublecomplex *e, int lde, doublecomplex *f, int ldf, double *scale, double *dif, int *info);
extern void ztpcon(char norm, char uplo, char diag, int n, doublecomplex *a, double *rcond, int *info);
extern void ztprfs(char uplo, char transa, char diag, int n, int nrhs, doublecomplex *a, doublecomplex *b, int ldb, doublecomplex *x, int ldx, double *ferr, double *berr, int *info);
extern void ztptri(char uplo, char diag, int n, doublecomplex *a, int *info);
extern void ztptrs(char uplo, char transa, char diag, int n, int nrhs, doublecomplex *a, doublecomplex *b, int ldb, int *info);
extern void ztrcon(char norm, char uplo, char diag, int n, doublecomplex *a, int lda, double *rcond, int *info);
extern void ztrevc(char side, char howmny, int *select, int n, doublecomplex *t, int ldt, doublecomplex *vl, int ldvl, doublecomplex *vr, int ldvr, int mm, int *m, int *info);
extern void ztrexc(char compq, int n, doublecomplex *t, int ldt, doublecomplex *q, int ldq, int ifst, int ilst, int *info);
extern void ztrrfs(char uplo, char transa, char diag, int n, int nrhs, doublecomplex *a, int lda, doublecomplex *b, int ldb, doublecomplex *x, int ldx, double *ferr, double *berr, int *info);
extern void ztrsen(char job, char compq, int *select, int n, doublecomplex *t, int ldt, doublecomplex *q, int ldq, doublecomplex *w, int *m, double *s, double *sep, int *info);
extern void ztrsna(char job, char howmny, int *select, int n, doublecomplex *t, int ldt, doublecomplex *vl, int ldvl, doublecomplex *vr, int ldvr, double *s, double *sep, int mm, int *m, int *info);
extern void ztrsyl(char trana, char tranb, int isgn, int m, int n, doublecomplex *a, int lda, doublecomplex *b, int ldb, doublecomplex *c, int ldc, double *scale, int *info);
extern void ztrtri(char uplo, char diag, int n, doublecomplex *a, int lda, int *info);
extern void ztrtrs(char uplo, char transa, char diag, int n, int nrhs, doublecomplex *a, int lda, doublecomplex *b, int ldb, int *info);
extern void ztzrqf(int m, int n, doublecomplex *a, int lda, doublecomplex *tau, int *info);
extern void ztzrzf(int m, int n, doublecomplex *a, int lda, doublecomplex *tau, int *info);
extern void zungbr(char vect, int m, int n, int k, doublecomplex *a, int lda, doublecomplex *tau, int *info);
extern void zunghr(int n, int ilo, int ihi, doublecomplex *a, int lda, doublecomplex *tau, int *info);
extern void zunglq(int m, int n, int k, doublecomplex *a, int lda, doublecomplex *tau, int *info);
extern void zungql(int m, int n, int k, doublecomplex *a, int lda, doublecomplex *tau, int *info);
extern void zungqr(int m, int n, int k, doublecomplex *a, int lda, doublecomplex *tau, int *info);
extern void zungrq(int m, int n, int k, doublecomplex *a, int lda, doublecomplex *tau, int *info);
extern void zungtr(char uplo, int n, doublecomplex *a, int lda, doublecomplex *tau, int *info);
extern void zunmbr(char vect, char side, char trans, int m, int n, int k, doublecomplex *a, int lda, doublecomplex *tau, doublecomplex *c, int ldc, int *info);
extern void zunmhr(char side, char trans, int m, int n, int ilo, int ihi, doublecomplex *a, int lda, doublecomplex *tau, doublecomplex *c, int ldc, int *info);
extern void zunmlq(char side, char trans, int m, int n, int k, doublecomplex *a, int lda, doublecomplex *tau, doublecomplex *c, int ldc, int *info);
extern void zunmql(char side, char trans, int m, int n, int k, doublecomplex *a, int lda, doublecomplex *tau, doublecomplex *c, int ldc, int *info);
extern void zunmqr(char side, char trans, int m, int n, int k, doublecomplex *a, int lda, doublecomplex *tau, doublecomplex *c, int ldc, int *info);
extern void zunmrq(char side, char trans, int m, int n, int k, doublecomplex *a, int lda, doublecomplex *tau, doublecomplex *c, int ldc, int *info);
extern void zunmrz(char side, char trans, int m, int n, int k, int l, doublecomplex *a, int lda, doublecomplex *tau, doublecomplex *c, int ldc, int *info);
extern void zunmtr(char side, char uplo, char trans, int m, int n, doublecomplex *a, int lda, doublecomplex *tau, doublecomplex *c, int ldc, int *info);
extern void zupgtr(char uplo, int n, doublecomplex *ap, doublecomplex *tau, doublecomplex *q, int ldq, int *info);
extern void zupmtr(char side, char uplo, char trans, int m, int n, doublecomplex *ap, doublecomplex *tau, doublecomplex *c, int ldc, int *info);

/* FFT C interfaces */
extern void cfft1d(int mode, int n, complex *x, complex *comm, int *info);
extern void cfft1dx(int mode, float scale, int inpl, int n, complex *x, int incx, complex *y, int incy, complex *comm, int *info);
extern void cfft1m(int mode, int nseq, int n, complex *x, complex *comm, int *info);
extern void cfft1mx(int mode, float scale, int inpl, int nseq, int n, complex *x, int incx1, int incx2, complex *y, int incy1, int incy2, complex *comm, int *info);
extern void cfft2d(int mode, int m, int n, complex *x, complex *comm, int *info);
extern void cfft2dx(int mode, float scale, int ltrans, int inpl, int m, int n, complex *x, int incx1, int incx2, complex *y, int incy1, int incy2, complex *comm, int *info);
extern void cfft3d(int mode, int l, int m, int n, complex *x, complex *comm, int *info);
extern void cfft3dx(int mode, float scale, int ltrans, int inpl, int l, int m, int n, complex *x, complex *y, complex *comm, int *info);
extern void cfft3dy(int mode, float scale, int inpl, int l, int m, int n, complex *x, int incx1, int incx2, int incx3, complex *y, int incy1, int incy2, int incy3, complex *comm, int lcomm, int *info);
extern void csfft(int mode, int n, float *x, float *comm, int *info);
extern void csfftm(int nseq, int n, float *x, float *comm, int *info);
extern void dzfft(int mode, int n, double *x, double *comm, int *info);
extern void dzfftm(int nseq, int n, double *x, double *comm, int *info);
extern void scfft(int mode, int n, float *x, float *comm, int *info);
extern void scfftm(int nseq, int n, float *x, float *comm, int *info);
extern void zdfft(int mode, int n, double *x, double *comm, int *info);
extern void zdfftm(int nseq, int n, double *x, double *comm, int *info);
extern void zfft1d(int mode, int n, doublecomplex *x, doublecomplex *comm, int *info);
extern void zfft1dx(int mode, double scale, int inpl, int n, doublecomplex *x, int incx, doublecomplex *y, int incy, doublecomplex *comm, int *info);
extern void zfft1m(int mode, int nseq, int n, doublecomplex *x, doublecomplex *comm, int *info);
extern void zfft1mx(int mode, double scale, int inpl, int nseq, int n, doublecomplex *x, int incx1, int incx2, doublecomplex *y, int incy1, int incy2, doublecomplex *comm, int *info);
extern void zfft2d(int mode, int m, int n, doublecomplex *x, doublecomplex *comm, int *info);
extern void zfft2dx(int mode, double scale, int ltrans, int inpl, int m, int n, doublecomplex *x, int incx1, int incx2, doublecomplex *y, int incy1, int incy2, doublecomplex *comm, int *info);
extern void zfft3d(int mode, int l, int m, int n, doublecomplex *x, doublecomplex *comm, int *info);
extern void zfft3dx(int mode, double scale, int ltrans, int inpl, int l, int m, int n, doublecomplex *x, doublecomplex *y, doublecomplex *comm, int *info);
extern void zfft3dy(int mode, double scale, int inpl, int l, int m, int n, doublecomplex *x, int incx1, int incx2, int incx3, doublecomplex *y, int incy1, int incy2, int incy3, doublecomplex *comm, int lcomm, int *info);

/* Sparse BLAS interfaces */
extern void caxpyi(int nz, complex a, complex *x, int *indx, complex *y);
extern complex cdotci(int nz, complex *x, int *indx, complex *y);
extern complex cdotui(int nz, complex *x, int *indx, complex *y);
extern void cgthr(int nz, complex *y, complex *x, int *indx);
extern void cgthrz(int nz, complex *y, complex *x, int *indx);
extern void csctr(int nz, complex *x, int *indx, complex *y);
extern void daxpyi(int nz, double a, double *x, int *indx, double *y);
extern double ddoti(int nz, double *x, int *indx, double *y);
extern void dgthr(int nz, double *y, double *x, int *indx);
extern void dgthrz(int nz, double *y, double *x, int *indx);
extern void droti(int nz, double *x, int *indx, double *y, double c, double s);
extern void dsctr(int nz, double *x, int *indx, double *y);
extern void saxpyi(int nz, float a, float *x, int *indx, float *y);
extern float sdoti(int nz, float *x, int *indx, float *y);
extern void sgthr(int nz, float *y, float *x, int *indx);
extern void sgthrz(int nz, float *y, float *x, int *indx);
extern void sroti(int nz, float *x, int *indx, float *y, float c, float s);
extern void ssctr(int nz, float *x, int *indx, float *y);
extern void zaxpyi(int nz, doublecomplex a, doublecomplex *x, int *indx, doublecomplex *y);
extern doublecomplex zdotci(int nz, doublecomplex *x, int *indx, doublecomplex *y);
extern doublecomplex zdotui(int nz, doublecomplex *x, int *indx, doublecomplex *y);
extern void zgthr(int nz, doublecomplex *y, doublecomplex *x, int *indx);
extern void zgthrz(int nz, doublecomplex *y, doublecomplex *x, int *indx);
extern void zsctr(int nz, doublecomplex *x, int *indx, doublecomplex *y);

/* Random number generators */
extern void drandbeta(int n, double a, double b, int *state, double *x, int *info);
extern void drandbinomial(int n, int m, double p, int *state, int *x, int *info);
extern void drandbinomialreference(int m, double p, double *ref, int *lref, int *info);
extern void drandblumblumshub(int n, int *state, double *x, int *info);
extern void drandcauchy(int n, double a, double b, int *state, double *x, int *info);
extern void drandchisquared(int n, int df, int *state, double *x, int *info);
extern void dranddiscreteuniform(int n, int a, int b, int *state, int *x, int *info);
extern void drandexponential(int n, double a, int *state, double *x, int *info);
extern void drandf(int n, int df1, int df2, int *state, double *x, int *info);
extern void drandgamma(int n, double a, double b, int *state, double *x, int *info);
extern void drandgaussian(int n, double xmu, double var, int *state, double *x, int *info);
extern void drandgeneraldiscrete(int n, double *ref, int *state, int *x, int *info);
extern void drandgeometric(int n, double p, int *state, int *x, int *info);
extern void drandgeometricreference(double p, double *ref, int *lref, int *info);
extern void drandhypergeometric(int n, int np, int ns, int m, int *state, int *x, int *info);
extern void drandhypergeometricreference(int np, int ns, int m, double *ref, int *lref, int *info);
extern void drandinitialize(int genid, int subid, int *seed, int *lseed, int *state, int *lstate, int *info);
extern void drandinitializebbs(int nbits, int lp, int *p, int lq, int *q, int ls, int *s, int *state, int *lstate, int *info);
extern void drandinitializeuser(ACML_DRANDINITIALIZEUSER_UINI uini, ACML_DRANDINITIALIZEUSER_UGEN ugen, int genid, int subid, int *seed, int *lseed, int *state, int *lstate, int *info);
extern void drandleapfrog(int n, int k, int *state, int *info);
extern void drandlogistic(int n, double a, double b, int *state, double *x, int *info);
extern void drandlognormal(int n, double xmu, double var, int *state, double *x, int *info);
extern void drandmultinomial(int n, int m, double *p, int k, int *state, int *x, int ldx, int *info);
extern void drandmultinormalreference(int m, double *xmu, double *c, int ldc, double *ref, int *lref, int *info);
extern void drandmultinormalr(int n, double *ref, int *state, double *x, int ldx, int *info);
extern void drandmultistudentstreference(int m, int df, double *xmu, double *c, int ldc, double *ref, int *lref, int *info);
extern void drandmultistudentstr(int n, double *ref, int *state, double *x, int ldx, int *info);
extern void drandnegativebinomial(int n, int m, double p, int *state, int *x, int *info);
extern void drandnegativebinomialreference(int m, double p, double *ref, int *lref, int *info);
extern void drandpoisson(int n, double lambda, int *state, int *x, int *info);
extern void drandpoissonreference(double lambda, double *ref, int *lref, int *info);
extern void drandskipahead(int n, int *state, int *info);
extern void drandstudentst(int n, int df, int *state, double *x, int *info);
extern void drandtriangular(int n, double xmin, double xmed, double xmax, int *state, double *x, int *info);
extern void dranduniform(int n, double a, double b, int *state, double *x, int *info);
extern void drandvonmises(int n, double vk, int *state, double *x, int *info);
extern void drandweibull(int n, double a, double b, int *state, double *x, int *info);
extern void drandmultinormal(int n, int m, double *xmu, double *c, int ldc, int *state, double *x, int ldx, int *info);
extern void drandmultistudentst(int n, int m, int df, double *xmu, double *c, int ldc, int *state, double *x, int ldx, int *info);
extern void srandbeta(int n, float a, float b, int *state, float *x, int *info);
extern void srandblumblumshub(int n, int *state, float *x, int *info);
extern void srandbinomial(int n, int m, float p, int *state, int *x, int *info);
extern void srandbinomialreference(int m, float p, float *ref, int *lref, int *info);
extern void srandcauchy(int n, float a, float b, int *state, float *x, int *info);
extern void srandchisquared(int n, int df, int *state, float *x, int *info);
extern void sranddiscreteuniform(int n, int a, int b, int *state, int *x, int *info);
extern void srandexponential(int n, float a, int *state, float *x, int *info);
extern void srandf(int n, int df1, int df2, int *state, float *x, int *info);
extern void srandgamma(int n, float a, float b, int *state, float *x, int *info);
extern void srandgaussian(int n, float xmu, float var, int *state, float *x, int *info);
extern void srandgeneraldiscrete(int n, float *ref, int *state, int *x, int *info);
extern void srandgeometric(int n, float p, int *state, int *x, int *info);
extern void srandgeometricreference(float p, float *ref, int *lref, int *info);
extern void srandhypergeometric(int n, int np, int ns, int m, int *state, int *x, int *info);
extern void srandhypergeometricreference(int np, int ns, int m, float *ref, int *lref, int *info);
extern void srandinitialize(int genid, int subid, int *seed, int *lseed, int *state, int *lstate, int *info);
extern void srandinitializebbs(int nbits, int lp, int *p, int lq, int *q, int ls, int *s, int *state, int *lstate, int *info);
extern void srandinitializeuser(ACML_SRANDINITIALIZEUSER_UINI uini, ACML_SRANDINITIALIZEUSER_UGEN ugen, int genid, int subid, int *seed, int *lseed, int *state, int *lstate, int *info);
extern void srandleapfrog(int n, int k, int *state, int *info);
extern void srandlogistic(int n, float a, float b, int *state, float *x, int *info);
extern void srandlognormal(int n, float xmu, float var, int *state, float *x, int *info);
extern void srandmultinomial(int n, int m, float *p, int k, int *state, int *x, int ldx, int *info);
extern void srandmultinormalreference(int m, float *xmu, float *c, int ldc, float *ref, int *lref, int *info);
extern void srandmultinormalr(int n, float *ref, int *state, float *x, int ldx, int *info);
extern void srandmultistudentstreference(int m, int df, float *xmu, float *c, int ldc, float *ref, int *lref, int *info);
extern void srandmultistudentstr(int n, float *ref, int *state, float *x, int ldx, int *info);
extern void srandnegativebinomial(int n, int m, float p, int *state, int *x, int *info);
extern void srandnegativebinomialreference(int m, float p, float *ref, int *lref, int *info);
extern void srandpoisson(int n, float lambda, int *state, int *x, int *info);
extern void srandpoissonreference(float lambda, float *ref, int *lref, int *info);
extern void srandskipahead(int n, int *state, int *info);
extern void srandstudentst(int n, int df, int *state, float *x, int *info);
extern void srandtriangular(int n, float xmin, float xmed, float xmax, int *state, float *x, int *info);
extern void sranduniform(int n, float a, float b, int *state, float *x, int *info);
extern void srandvonmises(int n, float vk, int *state, float *x, int *info);
extern void srandweibull(int n, float a, float b, int *state, float *x, int *info);
extern void srandmultinormal(int n, int m, float *xmu, float *c, int ldc, int *state, float *x, int ldx, int *info);
extern void srandmultistudentst(int n, int m, int df, float *xmu, float *c, int ldc, int *state, float *x, int ldx, int *info);

/* ACML version information */
extern void acmlversion(int *major, int *minor, int *patch);
extern void acmlinfo(void);

/* OMP interfaces */
extern int acmlgetmaxthreads(void);
extern int acmlgetnumthreads(void);
extern void acmlsetnumthreads(int numthreads);
extern int acmlgetnumprocs(void);

/* Basic complex arithmetic routines for C */
extern complex compose_complex(float x, float y);
extern float complex_real(complex z);
extern float complex_imag(complex z);
extern complex complex_negate(complex z);
extern complex complex_conjugate(complex z);
extern complex complex_add(complex z1, complex z2);
extern complex complex_subtract(complex z1, complex z2);
extern complex complex_multiply(complex z1, complex z2);
extern complex complex_divide(complex z1, complex z2);
extern int complex_equal(complex z1, complex z2);
extern int complex_notequal(complex z1, complex z2);
extern float complex_abs(complex z);

extern doublecomplex compose_doublecomplex(double x, double y);
extern double doublecomplex_real(doublecomplex z);
extern double doublecomplex_imag(doublecomplex z);
extern doublecomplex doublecomplex_negate(doublecomplex z);
extern doublecomplex doublecomplex_conjugate(doublecomplex z);
extern doublecomplex doublecomplex_add(doublecomplex z1, doublecomplex z2);
extern doublecomplex doublecomplex_subtract(doublecomplex z1, doublecomplex z2);
extern doublecomplex doublecomplex_multiply(doublecomplex z1, doublecomplex z2);
extern doublecomplex doublecomplex_divide(doublecomplex z1, doublecomplex z2);
extern int doublecomplex_equal(doublecomplex z1, doublecomplex z2);
extern int doublecomplex_notequal(doublecomplex z1, doublecomplex z2);
extern double doublecomplex_abs(doublecomplex z);

/* minmax utilities */
extern int acml_imax2(int a, int b);
extern int acml_imin2(int a, int b);
extern int acml_imax3(int a, int b, int c);
extern int acml_imin3(int a, int b, int c);
extern float acml_fmax2(float a, float b);
extern float acml_fmin2(float a, float b);
extern float acml_fmax3(float a, float b, float c);
extern float acml_fmin3(float a, float b, float c);
extern double acml_dmax2(double a, double b);
extern double acml_dmin2(double a, double b);
extern double acml_dmax3(double a, double b, double c);
extern double acml_dmin3(double a, double b, double c);

/* ------------------------------------------------------------------ */
/* Below are prototypes for the FORTRAN interfaces to ACML routines */

/*
   g77 promotes the return value of FORTRAN REAL functions to DOUBLE.
   Other compilers do not. If linking against a g77-compiled version
   of ACML, and calling such functions via their FORTRAN interface,
   (e.g. sasum_) the C programmer needs to be aware of this. Calling
   the C interface should always be safe. Functions affected in this
   way are the ACML BLAS functions:

          sasum_
          scasum_
          scnrm2_
          sdot_
          sdoti_
          sdsdot_
          snrm2_

   and the ACML LAPACK functions

          second_
          slamch_

   In order to get the expected behaviour, the macro
   FORTRAN_FLOAT_FUNCTIONS_RETURN_DOUBLE should be defined at the time
   of compilation of your C program which includes acml.h if you intend
   to call such a function from your C program and link to a g77-compiled
   version of ACML.

   N.B. the GNU gfortran compiler does NOT promote REAL to DOUBLE
   by default. Using the -ff2c flag with gfortran forces compatibility
   with g77 in this respect.
 */
/* BLAS routines */
extern void CAXPY(int *n, complex *alpha, complex *x, int *incx, complex *y, int *incy);
extern void CCOPY(int *n, complex *x, int *incx, complex *y, int *incy);
extern complex CDOTC(complex *ret_val, int *n, complex *x, int *incx, complex *y, int *incy);
extern void CDOTCSUB(complex *ret_val, int *n, complex *x, int *incx, complex *y, int *incy);
extern complex CDOTU(complex *ret_val, int *n, complex *x, int *incx, complex *y, int *incy);
extern void CDOTUSUB(complex *ret_val, int *n, complex *x, int *incx, complex *y, int *incy);
extern void CGBMV(char *trans, int *m, int *n, int *kl, int *ku, complex *alpha, complex *a, int *lda, complex *x, int *incx, complex *beta, complex *y, int *incy, int trans_len);
extern void CGEMM(char *transa, char *transb, int *m, int *n, int *k, complex *alpha, complex *a, int *lda, complex *b, int *ldb, complex *beta, complex *c, int *ldc, int transa_len, int transb_len);
extern void CGEMV(char *trans, int *m, int *n, complex *alpha, complex *a, int *lda, complex *x, int *incx, complex *beta, complex *y, int *incy, int trans_len);
extern void CGERC(int *m, int *n, complex *alpha, complex *x, int *incx, complex *y, int *incy, complex *a, int *lda);
extern void CGERU(int *m, int *n, complex *alpha, complex *x, int *incx, complex *y, int *incy, complex *a, int *lda);
extern void CHBMV(char *uplo, int *n, int *k, complex *alpha, complex *a, int *lda, complex *x, int *incx, complex *beta, complex *y, int *incy, int uplo_len);
extern void CHEMM(char *side, char *uplo, int *m, int *n, complex *alpha, complex *a, int *lda, complex *b, int *ldb, complex *beta, complex *c, int *ldc, int side_len, int uplo_len);
extern void CHEMV(char *uplo, int *n, complex *alpha, complex *a, int *lda, complex *x, int *incx, complex *beta, complex *y, int *incy, int uplo_len);
extern void CHER(char *uplo, int *n, float *alpha, complex *x, int *incx, complex *a, int *lda, int uplo_len);
extern void CHER2(char *uplo, int *n, complex *alpha, complex *x, int *incx, complex *y, int *incy, complex *a, int *lda, int uplo_len);
extern void CHER2K(char *uplo, char *trans, int *n, int *k, complex *alpha, complex *a, int *lda, complex *b, int *ldb, float *beta, complex *c, int *ldc, int uplo_len, int trans_len);
extern void CHERK(char *uplo, char *trans, int *n, int *k, float *alpha, complex *a, int *lda, float *beta, complex *c, int *ldc, int uplo_len, int trans_len);
extern void CHPMV(char *uplo, int *n, complex *alpha, complex *a, complex *x, int *incx, complex *beta, complex *y, int *incy, int uplo_len);
extern void CHPR(char *uplo, int *n, float *alpha, complex *x, int *incx, complex *a, int uplo_len);
extern void CHPR2(char *uplo, int *n, complex *alpha, complex *x, int *incx, complex *y, int *incy, complex *a, int uplo_len);
extern void CLASSQ(int *n, complex *x, int *incx, float *scale, float *sumsq);
extern void CROTG(complex *a, complex *b, float *c, complex *s);
extern void CSCAL(int *n, complex *alpha, complex *x, int *incx);
extern void CSROT(int *n, complex *x, int *incx, complex *y, int *incy, float *c, float *s);
extern void CSSCAL(int *n, float *alpha, complex *x, int *incx);
extern void CSTEMR(char *jobz, char *range, int *n, float *d, float *e, float *vl, float *vu, int *il, int *iu, int *m, float *w, complex *z, int *ldz, int *nzc, int *isuppz, int *tryrac, float *work, int *lwork, int *iwork, int *liwork, int *info, int jobz_len, int range_len);
extern void CSWAP(int *n, complex *x, int *incx, complex *y, int *incy);
extern void CSYMM(char *side, char *uplo, int *m, int *n, complex *alpha, complex *a, int *lda, complex *b, int *ldb, complex *beta, complex *c, int *ldc, int side_len, int uplo_len);
extern void CSYR2K(char *uplo, char *trans, int *n, int *k, complex *alpha, complex *a, int *lda, complex *b, int *ldb, complex *beta, complex *c, int *ldc, int uplo_len, int trans_len);
extern void CSYRK(char *uplo, char *trans, int *n, int *k, complex *alpha, complex *a, int *lda, complex *beta, complex *c, int *ldc, int uplo_len, int trans_len);
extern void CTBMV(char *uplo, char *trans, char *diag, int *n, int *k, complex *a, int *lda, complex *x, int *incx, int uplo_len, int trans_len, int diag_len);
extern void CTBSV(char *uplo, char *trans, char *diag, int *n, int *k, complex *a, int *lda, complex *x, int *incx, int uplo_len, int trans_len, int diag_len);
extern void CTPMV(char *uplo, char *trans, char *diag, int *n, complex *ap, complex *x, int *incx, int uplo_len, int trans_len, int diag_len);
extern void CTPSV(char *uplo, char *trans, char *diag, int *n, complex *ap, complex *x, int *incx, int uplo_len, int trans_len, int diag_len);
extern void CTRMM(char *side, char *uplo, char *transa, char *diag, int *m, int *n, complex *alpha, complex *a, int *lda, complex *b, int *ldb, int side_len, int uplo_len, int transa_len, int diag_len);
extern void CTRMV(char *uplo, char *trans, char *diag, int *n, complex *a, int *lda, complex *x, int *incx, int uplo_len, int trans_len, int diag_len);
extern void CTRSM(char *side, char *uplo, char *transa, char *diag, int *m, int *n, complex *alpha, complex *a, int *lda, complex *b, int *ldb, int side_len, int uplo_len, int transa_len, int diag_len);
extern void CTRSV(char *uplo, char *trans, char *diag, int *n, complex *a, int *lda, complex *x, int *incx, int uplo_len, int trans_len, int diag_len);
extern double DASUM(int *n, double *x, int *incx);
extern void DAXPY(int *n, double *alpha, double *x, int *incx, double *y, int *incy);
extern double DCABS1(doublecomplex *z);
extern void DCOPY(int *n, double *x, int *incx, double *y, int *incy);
extern double DDOT(int *n, double *x, int *incx, double *y, int *incy);
extern void DGBMV(char *trans, int *m, int *n, int *kl, int *ku, double *alpha, double *a, int *lda, double *x, int *incx, double *beta, double *y, int *incy, int trans_len);
extern void DGEMM(char *transa, char *transb, int *m, int *n, int *k, double *alpha, double *a, int *lda, double *b, int *ldb, double *beta, double *c, int *ldc, int transa_len, int transb_len);
extern void DGEMV(char *trans, int *m, int *n, double *alpha, double *a, int *lda, double *x, int *incx, double *beta, double *y, int *incy, int trans_len);
extern void DGER(int *m, int *n, double *alpha, double *x, int *incx, double *y, int *incy, double *a, int *lda);
extern double DNRM2(int *n, double *x, int *incx);
extern void DROT(int *n, double *x, int *incx, double *y, int *incy, double *c, double *s);
extern void DROTG(double *a, double *b, double *c, double *s);
extern void DROTM(int *n, double *x, int *incx, double *y, int *incy, double *param);
extern void DROTMG(double *d1, double *d2, double *b1, double *b2, double *param);
extern void DSBMV(char *uplo, int *n, int *k, double *alpha, double *a, int *lda, double *x, int *incx, double *beta, double *y, int *incy, int uplo_len);
extern void DSCAL(int *n, double *alpha, double *x, int *incx);
extern double DSDOT(int *n, float *sx, int *incx, float *sy, int *incy);
extern void DSPMV(char *uplo, int *n, double *alpha, double *ap, double *x, int *incx, double *beta, double *y, int *incy, int uplo_len);
extern void DSPR(char *uplo, int *n, double *alpha, double *x, int *incx, double *ap, int uplo_len);
extern void DSPR2(char *uplo, int *n, double *alpha, double *x, int *incx, double *y, int *incy, double *ap, int uplo_len);
extern void DSWAP(int *n, double *x, int *incx, double *y, int *incy);
extern void DSYMM(char *side, char *uplo, int *m, int *n, double *alpha, double *a, int *lda, double *b, int *ldb, double *beta, double *c, int *ldc, int side_len, int uplo_len);
extern void DSYMV(char *uplo, int *n, double *alpha, double *a, int *lda, double *x, int *incx, double *beta, double *y, int *incy, int uplo_len);
extern void DSYR(char *uplo, int *n, double *alpha, double *x, int *incx, double *a, int *lda, int uplo_len);
extern void DSYR2(char *uplo, int *n, double *alpha, double *x, int *incx, double *y, int *incy, double *a, int *lda, int uplo_len);
extern void DSYR2K(char *uplo, char *trans, int *n, int *k, double *alpha, double *a, int *lda, double *b, int *ldb, double *beta, double *c, int *ldc, int uplo_len, int trans_len);
extern void DSYRK(char *uplo, char *trans, int *n, int *k, double *alpha, double *a, int *lda, double *beta, double *c, int *ldc, int uplo_len, int trans_len);
extern void DTBMV(char *uplo, char *trans, char *diag, int *n, int *k, double *a, int *lda, double *x, int *incx, int uplo_len, int trans_len, int diag_len);
extern void DTBSV(char *uplo, char *trans, char *diag, int *n, int *k, double *a, int *lda, double *x, int *incx, int uplo_len, int trans_len, int diag_len);
extern void DTPMV(char *uplo, char *trans, char *diag, int *n, double *ap, double *x, int *incx, int uplo_len, int trans_len, int diag_len);
extern void DTPSV(char *uplo, char *trans, char *diag, int *n, double *ap, double *x, int *incx, int uplo_len, int trans_len, int diag_len);
extern void DTRMM(char *side, char *uplo, char *transa, char *diag, int *m, int *n, double *alpha, double *a, int *lda, double *b, int *ldb, int side_len, int uplo_len, int transa_len, int diag_len);
extern void DTRMV(char *uplo, char *trans, char *diag, int *n, double *a, int *lda, double *x, int *incx, int uplo_len, int trans_len, int diag_len);
extern void DTRSM(char *side, char *uplo, char *transa, char *diag, int *m, int *n, double *alpha, double *a, int *lda, double *b, int *ldb, int side_len, int uplo_len, int transa_len, int diag_len);
extern void DTRSV(char *uplo, char *trans, char *diag, int *n, double *a, int *lda, double *x, int *incx, int uplo_len, int trans_len, int diag_len);
extern double DZASUM(int *n, doublecomplex *x, int *incx);
extern double DZNRM2(int *n, doublecomplex *x, int *incx);
extern int ICAMAX(int *n, complex *x, int *incx);
extern int IDAMAX(int *n, double *x, int *incx);
extern int ISAMAX(int *n, float *x, int *incx);
extern int IZAMAX(int *n, doublecomplex *x, int *incx);
extern int LSAME(char *ca, char *cb, int ca_len, int cb_len);

#ifdef FORTRAN_FLOAT_FUNCTIONS_RETURN_DOUBLE
extern double SASUM(int *n, float *x, int *incx);
#else
extern float SASUM(int *n, float *x, int *incx);
#endif

extern void SAXPY(int *n, float *alpha, float *x, int *incx, float *y, int *incy);

#ifdef FORTRAN_FLOAT_FUNCTIONS_RETURN_DOUBLE
extern double SCASUM(int *n, complex *x, int *incx);
extern double SCNRM2(int *n, complex *x, int *incx);
#else
extern float SCASUM(int *n, complex *x, int *incx);
extern float SCNRM2(int *n, complex *x, int *incx);
#endif

extern void SCOPY(int *n, float *x, int *incx, float *y, int *incy);

#ifdef FORTRAN_FLOAT_FUNCTIONS_RETURN_DOUBLE
extern double SDOT(int *n, float *x, int *incx, float *y, int *incy);
extern double SDSDOT(int *n, float *b, float *x, int *incx, float *y, int *incy);
#else
extern float SDOT(int *n, float *x, int *incx, float *y, int *incy);
extern float SDSDOT(int *n, float *b, float *x, int *incx, float *y, int *incy);
#endif

extern void SGBMV(char *trans, int *m, int *n, int *kl, int *ku, float *alpha, float *a, int *lda, float *x, int *incx, float *beta, float *y, int *incy, int trans_len);
extern void SGEMM(char *transa, char *transb, int *m, int *n, int *k, float *alpha, float *a, int *lda, float *b, int *ldb, float *beta, float *c, int *ldc, int transa_len, int transb_len);
extern void SGEMV(char *trans, int *m, int *n, float *alpha, float *a, int *lda, float *x, int *incx, float *beta, float *y, int *incy, int trans_len);
extern void SGER(int *m, int *n, float *alpha, float *x, int *incx, float *y, int *incy, float *a, int *lda);

#ifdef FORTRAN_FLOAT_FUNCTIONS_RETURN_DOUBLE
extern double SNRM2(int *n, float *x, int *incx);
#else
extern float SNRM2(int *n, float *x, int *incx);
#endif

extern void SROT(int *n, float *x, int *incx, float *y, int *incy, float *c, float *s);
extern void SROTG(float *a, float *b, float *c, float *s);
extern void SROTM(int *n, float *x, int *incx, float *y, int *incy, float *param);
extern void SROTMG(float *d1, float *d2, float *b1, float *b2, float *param);
extern void SSBMV(char *uplo, int *n, int *k, float *alpha, float *a, int *lda, float *x, int *incx, float *beta, float *y, int *incy, int uplo_len);
extern void SSCAL(int *n, float *alpha, float *x, int *incx);
extern void SSPMV(char *uplo, int *n, float *alpha, float *ap, float *x, int *incx, float *beta, float *y, int *incy, int uplo_len);
extern void SSPR(char *uplo, int *n, float *alpha, float *x, int *incx, float *ap, int uplo_len);
extern void SSPR2(char *uplo, int *n, float *alpha, float *x, int *incx, float *y, int *incy, float *ap, int uplo_len);
extern void SSTEMR(char *jobz, char *range, int *n, float *d, float *e, float *vl, float *vu, int *il, int *iu, int *m, float *w, float *z, int *ldz, int *nzc, int *isuppz, int *tryrac, float *work, int *lwork, int *iwork, int *liwork, int *info, int jobz_len, int range_len);
extern void SSWAP(int *n, float *x, int *incx, float *y, int *incy);
extern void SSYMM(char *side, char *uplo, int *m, int *n, float *alpha, float *a, int *lda, float *b, int *ldb, float *beta, float *c, int *ldc, int side_len, int uplo_len);
extern void SSYMV(char *uplo, int *n, float *alpha, float *a, int *lda, float *x, int *incx, float *beta, float *y, int *incy, int uplo_len);
extern void SSYR(char *uplo, int *n, float *alpha, float *x, int *incx, float *a, int *lda, int uplo_len);
extern void SSYR2(char *uplo, int *n, float *alpha, float *x, int *incx, float *y, int *incy, float *a, int *lda, int uplo_len);
extern void SSYR2K(char *uplo, char *trans, int *n, int *k, float *alpha, float *a, int *lda, float *b, int *ldb, float *beta, float *c, int *ldc, int uplo_len, int trans_len);
extern void SSYRK(char *uplo, char *trans, int *n, int *k, float *alpha, float *a, int *lda, float *beta, float *c, int *ldc, int uplo_len, int trans_len);
extern void STBMV(char *uplo, char *trans, char *diag, int *n, int *k, float *a, int *lda, float *x, int *incx, int uplo_len, int trans_len, int diag_len);
extern void STBSV(char *uplo, char *trans, char *diag, int *n, int *k, float *a, int *lda, float *x, int *incx, int uplo_len, int trans_len, int diag_len);
extern void STPMV(char *uplo, char *trans, char *diag, int *n, float *ap, float *x, int *incx, int uplo_len, int trans_len, int diag_len);
extern void STPSV(char *uplo, char *trans, char *diag, int *n, float *ap, float *x, int *incx, int uplo_len, int trans_len, int diag_len);
extern void STRMM(char *side, char *uplo, char *transa, char *diag, int *m, int *n, float *alpha, float *a, int *lda, float *b, int *ldb, int side_len, int uplo_len, int transa_len, int diag_len);
extern void STRMV(char *uplo, char *trans, char *diag, int *n, float *a, int *lda, float *x, int *incx, int uplo_len, int trans_len, int diag_len);
extern void STRSM(char *side, char *uplo, char *transa, char *diag, int *m, int *n, float *alpha, float *a, int *lda, float *b, int *ldb, int side_len, int uplo_len, int transa_len, int diag_len);
extern void STRSV(char *uplo, char *trans, char *diag, int *n, float *a, int *lda, float *x, int *incx, int uplo_len, int trans_len, int diag_len);
extern void XERBLA(const char *srname, int *info, int srname_len);
extern void ZAXPY(int *n, doublecomplex *alpha, doublecomplex *x, int *incx, doublecomplex *y, int *incy);
extern void ZCOPY(int *n, doublecomplex *x, int *incx, doublecomplex *y, int *incy);
extern doublecomplex ZDOTC(doublecomplex *ret_val, int *n, doublecomplex *x, int *incx, doublecomplex *y, int *incy);
extern void ZDOTCSUB(doublecomplex *ret_val, int *n, doublecomplex *x, int *incx, doublecomplex *y, int *incy);
extern doublecomplex ZDOTU(doublecomplex *ret_val, int *n, doublecomplex *x, int *incx, doublecomplex *y, int *incy);
extern void ZDOTUSUB(doublecomplex *ret_val, int *n, doublecomplex *x, int *incx, doublecomplex *y, int *incy);
extern void ZDROT(int *n, doublecomplex *x, int *incx, doublecomplex *y, int *incy, double *c, double *s);
extern void ZDSCAL(int *n, double *alpha, doublecomplex *x, int *incx);
extern void ZGBMV(char *trans, int *m, int *n, int *kl, int *ku, doublecomplex *alpha, doublecomplex *a, int *lda, doublecomplex *x, int *incx, doublecomplex *beta, doublecomplex *y, int *incy, int trans_len);
extern void ZGEMM(char *transa, char *transb, int *m, int *n, int *k, doublecomplex *alpha, doublecomplex *a, int *lda, doublecomplex *b, int *ldb, doublecomplex *beta, doublecomplex *c, int *ldc, int transa_len, int transb_len);
extern void ZGEMV(char *trans, int *m, int *n, doublecomplex *alpha, doublecomplex *a, int *lda, doublecomplex *x, int *incx, doublecomplex *beta, doublecomplex *y, int *incy, int trans_len);
extern void ZGERC(int *m, int *n, doublecomplex *alpha, doublecomplex *x, int *incx, doublecomplex *y, int *incy, doublecomplex *a, int *lda);
extern void ZGERU(int *m, int *n, doublecomplex *alpha, doublecomplex *x, int *incx, doublecomplex *y, int *incy, doublecomplex *a, int *lda);
extern void ZHBMV(char *uplo, int *n, int *k, doublecomplex *alpha, doublecomplex *a, int *lda, doublecomplex *x, int *incx, doublecomplex *beta, doublecomplex *y, int *incy, int uplo_len);
extern void ZHEMM(char *side, char *uplo, int *m, int *n, doublecomplex *alpha, doublecomplex *a, int *lda, doublecomplex *b, int *ldb, doublecomplex *beta, doublecomplex *c, int *ldc, int side_len, int uplo_len);
extern void ZHEMV(char *uplo, int *n, doublecomplex *alpha, doublecomplex *a, int *lda, doublecomplex *x, int *incx, doublecomplex *beta, doublecomplex *y, int *incy, int uplo_len);
extern void ZHER(char *uplo, int *n, double *alpha, doublecomplex *x, int *incx, doublecomplex *a, int *lda, int uplo_len);
extern void ZHER2(char *uplo, int *n, doublecomplex *alpha, doublecomplex *x, int *incx, doublecomplex *y, int *incy, doublecomplex *a, int *lda, int uplo_len);
extern void ZHER2K(char *uplo, char *trans, int *n, int *k, doublecomplex *alpha, doublecomplex *a, int *lda, doublecomplex *b, int *ldb, double *beta, doublecomplex *c, int *ldc, int uplo_len, int trans_len);
extern void ZHERK(char *uplo, char *trans, int *n, int *k, double *alpha, doublecomplex *a, int *lda, double *beta, doublecomplex *c, int *ldc, int uplo_len, int trans_len);
extern void ZHPMV(char *uplo, int *n, doublecomplex *alpha, doublecomplex *a, doublecomplex *x, int *incx, doublecomplex *beta, doublecomplex *y, int *incy, int uplo_len);
extern void ZHPR(char *uplo, int *n, double *alpha, doublecomplex *x, int *incx, doublecomplex *a, int uplo_len);
extern void ZHPR2(char *uplo, int *n, doublecomplex *alpha, doublecomplex *x, int *incx, doublecomplex *y, int *incy, doublecomplex *a, int uplo_len);
extern void ZLASSQ(int *n, doublecomplex *x, int *incx, double *scale, double *sumsq);
extern void ZROTG(doublecomplex *a, doublecomplex *b, double *c, doublecomplex *s);
extern void ZSCAL(int *n, doublecomplex *alpha, doublecomplex *x, int *incx);
extern void ZSTEMR(char *jobz, char *range, int *n, double *d, double *e, double *vl, double *vu, int *il, int *iu, int *m, double *w, doublecomplex *z, int *ldz, int *nzc, int *isuppz, int *tryrac, double *work, int *lwork, int *iwork, int *liwork, int *info, int jobz_len, int range_len);
extern void ZSWAP(int *n, doublecomplex *x, int *incx, doublecomplex *y, int *incy);
extern void ZSYMM(char *side, char *uplo, int *m, int *n, doublecomplex *alpha, doublecomplex *a, int *lda, doublecomplex *b, int *ldb, doublecomplex *beta, doublecomplex *c, int *ldc, int side_len, int uplo_len);
extern void ZSYR2K(char *uplo, char *trans, int *n, int *k, doublecomplex *alpha, doublecomplex *a, int *lda, doublecomplex *b, int *ldb, doublecomplex *beta, doublecomplex *c, int *ldc, int uplo_len, int trans_len);
extern void ZSYRK(char *uplo, char *trans, int *n, int *k, doublecomplex *alpha, doublecomplex *a, int *lda, doublecomplex *beta, doublecomplex *c, int *ldc, int uplo_len, int trans_len);
extern void ZTBMV(char *uplo, char *trans, char *diag, int *n, int *k, doublecomplex *a, int *lda, doublecomplex *x, int *incx, int uplo_len, int trans_len, int diag_len);
extern void ZTBSV(char *uplo, char *trans, char *diag, int *n, int *k, doublecomplex *a, int *lda, doublecomplex *x, int *incx, int uplo_len, int trans_len, int diag_len);
extern void ZTPMV(char *uplo, char *trans, char *diag, int *n, doublecomplex *ap, doublecomplex *x, int *incx, int uplo_len, int trans_len, int diag_len);
extern void ZTPSV(char *uplo, char *trans, char *diag, int *n, doublecomplex *ap, doublecomplex *x, int *incx, int uplo_len, int trans_len, int diag_len);
extern void ZTRMM(char *side, char *uplo, char *transa, char *diag, int *m, int *n, doublecomplex *alpha, doublecomplex *a, int *lda, doublecomplex *b, int *ldb, int side_len, int uplo_len, int transa_len, int diag_len);
extern void ZTRMV(char *uplo, char *trans, char *diag, int *n, doublecomplex *a, int *lda, doublecomplex *x, int *incx, int uplo_len, int trans_len, int diag_len);
extern void ZTRSM(char *side, char *uplo, char *transa, char *diag, int *m, int *n, doublecomplex *alpha, doublecomplex *a, int *lda, doublecomplex *b, int *ldb, int side_len, int uplo_len, int transa_len, int diag_len);
extern void ZTRSV(char *uplo, char *trans, char *diag, int *n, doublecomplex *a, int *lda, doublecomplex *x, int *incx, int uplo_len, int trans_len, int diag_len);

/* LAPACK routines */
extern int ILAENV(int *ispec, const char *name, const char *opts, int *n1, int *n2, int *n3, int *n4, int name_len, int opts_len);
extern void ILAENVSET(int *ispec, const char *name, const char *opts, int *n1, int *n2, int *n3, int *n4, int *nvalue, int *info, int name_len, int opts_len);
extern void ILAVER(int *vers_major, int *vers_minor, int *vers_patch);
extern void CBDSQR(char *uplo, int *n, int *ncvt, int *nru, int *ncc, float *d, float *e, complex *vt, int *ldvt, complex *u, int *ldu, complex *c, int *ldc, float *rwork, int *info, int uplo_len);
extern void CGBBRD(char *vect, int *m, int *n, int *ncc, int *kl, int *ku, complex *ab, int *ldab, float *d, float *e, complex *q, int *ldq, complex *pt, int *ldpt, complex *c, int *ldc, complex *work, float *rwork, int *info, int vect_len);
extern void CGBCON(char *norm, int *n, int *kl, int *ku, complex *ab, int *ldab, int *ipiv, float *anorm, float *rcond, complex *work, float *rwork, int *info, int norm_len);
extern void CGBEQU(int *m, int *n, int *kl, int *ku, complex *ab, int *ldab, float *r, float *c, float *rowcnd, float *colcnd, float *amax, int *info);
extern void CGBRFS(char *trans, int *n, int *kl, int *ku, int *nrhs, complex *ab, int *ldab, complex *afb, int *ldafb, int *ipiv, complex *b, int *ldb, complex *x, int *ldx, float *ferr, float *berr, complex *work, float *rwork, int *info, int trans_len);
extern void CGBSV(int *n, int *kl, int *ku, int *nrhs, complex *ab, int *ldab, int *ipiv, complex *b, int *ldb, int *info);
extern void CGBSVX(char *fact, char *trans, int *n, int *kl, int *ku, int *nrhs, complex *ab, int *ldab, complex *afb, int *ldafb, int *ipiv, char *equed, float *r, float *c, complex *b, int *ldb, complex *x, int *ldx, float *rcond, float *ferr, float *berr, complex *work, float *rwork, int *info, int fact_len, int trans_len, int equed_len);
extern void CGBTRF(int *m, int *n, int *kl, int *ku, complex *ab, int *ldab, int *ipiv, int *info);
extern void CGBTRS(char *trans, int *n, int *kl, int *ku, int *nrhs, complex *ab, int *ldab, int *ipiv, complex *b, int *ldb, int *info, int trans_len);
extern void CGEBAK(char *job, char *side, int *n, int *ilo, int *ihi, float *scale, int *m, complex *v, int *ldv, int *info, int job_len, int side_len);
extern void CGEBAL(char *job, int *n, complex *a, int *lda, int *ilo, int *ihi, float *scale, int *info, int job_len);
extern void CGEBRD(int *m, int *n, complex *a, int *lda, float *d, float *e, complex *tauq, complex *taup, complex *work, int *lwork, int *info);
extern void CGECON(char *norm, int *n, complex *a, int *lda, float *anorm, float *rcond, complex *work, float *rwork, int *info, int norm_len);
extern void CGEEQU(int *m, int *n, complex *a, int *lda, float *r, float *c, float *rowcnd, float *colcnd, float *amax, int *info);
extern void CGEES(char *jobvs, char *sort, ACML_CGEES_SELECT select, int *n, complex *a, int *lda, int *sdim, complex *w, complex *vs, int *ldvs, complex *work, int *lwork, float *rwork, int *bwork, int *info, int jobvs_len, int sort_len);
extern void CGEESX(char *jobvs, char *sort, ACML_CGEESX_SELECT select, char *sense, int *n, complex *a, int *lda, int *sdim, complex *w, complex *vs, int *ldvs, float *rconde, float *rcondv, complex *work, int *lwork, float *rwork, int *bwork, int *info, int jobvs_len, int sort_len, int sense_len);
extern void CGEEV(char *jobvl, char *jobvr, int *n, complex *a, int *lda, complex *w, complex *vl, int *ldvl, complex *vr, int *ldvr, complex *work, int *lwork, float *rwork, int *info, int jobvl_len, int jobvr_len);
extern void CGEEVX(char *balanc, char *jobvl, char *jobvr, char *sense, int *n, complex *a, int *lda, complex *w, complex *vl, int *ldvl, complex *vr, int *ldvr, int *ilo, int *ihi, float *scale, float *abnrm, float *rconde, float *rcondv, complex *work, int *lwork, float *rwork, int *info, int balanc_len, int jobvl_len, int jobvr_len, int sense_len);
extern void CGEGS(char *jobvsl, char *jobvsr, int *n, complex *a, int *lda, complex *b, int *ldb, complex *alpha, complex *beta, complex *vsl, int *ldvsl, complex *vsr, int *ldvsr, complex *work, int *lwork, float *rwork, int *info, int jobvsl_len, int jobvsr_len);
extern void CGEGV(char *jobvl, char *jobvr, int *n, complex *a, int *lda, complex *b, int *ldb, complex *alpha, complex *beta, complex *vl, int *ldvl, complex *vr, int *ldvr, complex *work, int *lwork, float *rwork, int *info, int jobvl_len, int jobvr_len);
extern void CGEHRD(int *n, int *ilo, int *ihi, complex *a, int *lda, complex *tau, complex *work, int *lwork, int *info);
extern void CGELQF(int *m, int *n, complex *a, int *lda, complex *tau, complex *work, int *lwork, int *info);
extern void CGELS(char *trans, int *m, int *n, int *nrhs, complex *a, int *lda, complex *b, int *ldb, complex *work, int *lwork, int *info, int trans_len);
extern void CGELSD(int *m, int *n, int *nrhs, complex *a, int *lda, complex *b, int *ldb, float *s, float *rcond, int *rank, complex *work, int *lwork, float *rwork, int *iwork, int *info);
extern void CGELSS(int *m, int *n, int *nrhs, complex *a, int *lda, complex *b, int *ldb, float *s, float *rcond, int *rank, complex *work, int *lwork, float *rwork, int *info);
extern void CGELSX(int *m, int *n, int *nrhs, complex *a, int *lda, complex *b, int *ldb, int *jpvt, float *rcond, int *rank, complex *work, float *rwork, int *info);
extern void CGELSY(int *m, int *n, int *nrhs, complex *a, int *lda, complex *b, int *ldb, int *jpvt, float *rcond, int *rank, complex *work, int *lwork, float *rwork, int *info);
extern void CGEQLF(int *m, int *n, complex *a, int *lda, complex *tau, complex *work, int *lwork, int *info);
extern void CGEQP3(int *m, int *n, complex *a, int *lda, int *jpvt, complex *tau, complex *work, int *lwork, float *rwork, int *info);
extern void CGEQPF(int *m, int *n, complex *a, int *lda, int *jpvt, complex *tau, complex *work, float *rwork, int *info);
extern void CGEQRF(int *m, int *n, complex *a, int *lda, complex *tau, complex *work, int *lwork, int *info);
extern void CGERFS(char *trans, int *n, int *nrhs, complex *a, int *lda, complex *af, int *ldaf, int *ipiv, complex *b, int *ldb, complex *x, int *ldx, float *ferr, float *berr, complex *work, float *rwork, int *info, int trans_len);
extern void CGERQF(int *m, int *n, complex *a, int *lda, complex *tau, complex *work, int *lwork, int *info);
extern void CGESDD(char *jobz, int *m, int *n, complex *a, int *lda, float *s, complex *u, int *ldu, complex *vt, int *ldvt, complex *work, int *lwork, float *rwork, int *iwork, int *info, int jobz_len);
extern void CGESV(int *n, int *nrhs, complex *a, int *lda, int *ipiv, complex *b, int *ldb, int *info);
extern void CGESVD(char *jobu, char *jobvt, int *m, int *n, complex *a, int *lda, float *s, complex *u, int *ldu, complex *vt, int *ldvt, complex *work, int *lwork, float *rwork, int *info, int jobu_len, int jobvt_len);
extern void CGESVX(char *fact, char *trans, int *n, int *nrhs, complex *a, int *lda, complex *af, int *ldaf, int *ipiv, char *equed, float *r, float *c, complex *b, int *ldb, complex *x, int *ldx, float *rcond, float *ferr, float *berr, complex *work, float *rwork, int *info, int fact_len, int trans_len, int equed_len);
extern void CGETRF(int *m, int *n, complex *a, int *lda, int *ipiv, int *info);
extern void CGETRI(int *n, complex *a, int *lda, int *ipiv, complex *work, int *lwork, int *info);
extern void CGETRS(char *trans, int *n, int *nrhs, complex *a, int *lda, int *ipiv, complex *b, int *ldb, int *info, int trans_len);
extern void CGGBAK(char *job, char *side, int *n, int *ilo, int *ihi, float *lscale, float *rscale, int *m, complex *v, int *ldv, int *info, int job_len, int side_len);
extern void CGGBAL(char *job, int *n, complex *a, int *lda, complex *b, int *ldb, int *ilo, int *ihi, float *lscale, float *rscale, float *work, int *info, int job_len);
extern void CGGES(char *jobvsl, char *jobvsr, char *sort, ACML_CGGES_SELCTG selctg, int *n, complex *a, int *lda, complex *b, int *ldb, int *sdim, complex *alpha, complex *beta, complex *vsl, int *ldvsl, complex *vsr, int *ldvsr, complex *work, int *lwork, float *rwork, int *bwork, int *info, int jobvsl_len, int jobvsr_len, int sort_len);
extern void CGGESX(char *jobvsl, char *jobvsr, char *sort, ACML_CGGESX_SELCTG selctg, char *sense, int *n, complex *a, int *lda, complex *b, int *ldb, int *sdim, complex *alpha, complex *beta, complex *vsl, int *ldvsl, complex *vsr, int *ldvsr, float *rconde, float *rcondv, complex *work, int *lwork, float *rwork, int *iwork, int *liwork, int *bwork, int *info, int jobvsl_len, int jobvsr_len, int sort_len, int sense_len);
extern void CGGEV(char *jobvl, char *jobvr, int *n, complex *a, int *lda, complex *b, int *ldb, complex *alpha, complex *beta, complex *vl, int *ldvl, complex *vr, int *ldvr, complex *work, int *lwork, float *rwork, int *info, int jobvl_len, int jobvr_len);
extern void CGGEVX(char *balanc, char *jobvl, char *jobvr, char *sense, int *n, complex *a, int *lda, complex *b, int *ldb, complex *alpha, complex *beta, complex *vl, int *ldvl, complex *vr, int *ldvr, int *ilo, int *ihi, float *lscale, float *rscale, float *abnrm, float *bbnrm, float *rconde, float *rcondv, complex *work, int *lwork, float *rwork, int *iwork, int *bwork, int *info, int balanc_len, int jobvl_len, int jobvr_len, int sense_len);
extern void CGGGLM(int *n, int *m, int *p, complex *a, int *lda, complex *b, int *ldb, complex *d, complex *x, complex *y, complex *work, int *lwork, int *info);
extern void CGGHRD(char *compq, char *compz, int *n, int *ilo, int *ihi, complex *a, int *lda, complex *b, int *ldb, complex *q, int *ldq, complex *z, int *ldz, int *info, int compq_len, int compz_len);
extern void CGGLSE(int *m, int *n, int *p, complex *a, int *lda, complex *b, int *ldb, complex *c, complex *d, complex *x, complex *work, int *lwork, int *info);
extern void CGGQRF(int *n, int *m, int *p, complex *a, int *lda, complex *taua, complex *b, int *ldb, complex *taub, complex *work, int *lwork, int *info);
extern void CGGRQF(int *m, int *p, int *n, complex *a, int *lda, complex *taua, complex *b, int *ldb, complex *taub, complex *work, int *lwork, int *info);
extern void CGGSVD(char *jobu, char *jobv, char *jobq, int *m, int *n, int *p, int *k, int *l, complex *a, int *lda, complex *b, int *ldb, float *alpha, float *beta, complex *u, int *ldu, complex *v, int *ldv, complex *q, int *ldq, complex *work, float *rwork, int *iwork, int *info, int jobu_len, int jobv_len, int jobq_len);
extern void CGGSVP(char *jobu, char *jobv, char *jobq, int *m, int *p, int *n, complex *a, int *lda, complex *b, int *ldb, float *tola, float *tolb, int *k, int *l, complex *u, int *ldu, complex *v, int *ldv, complex *q, int *ldq, int *iwork, float *rwork, complex *tau, complex *work, int *info, int jobu_len, int jobv_len, int jobq_len);
extern void CGTCON(char *norm, int *n, complex *dl, complex *d, complex *du, complex *du2, int *ipiv, float *anorm, float *rcond, complex *work, int *info, int norm_len);
extern void CGTRFS(char *trans, int *n, int *nrhs, complex *dl, complex *d, complex *du, complex *dlf, complex *df, complex *duf, complex *du2, int *ipiv, complex *b, int *ldb, complex *x, int *ldx, float *ferr, float *berr, complex *work, float *rwork, int *info, int trans_len);
extern void CGTSV(int *n, int *nrhs, complex *dl, complex *d, complex *du, complex *b, int *ldb, int *info);
extern void CGTSVX(char *fact, char *trans, int *n, int *nrhs, complex *dl, complex *d, complex *du, complex *dlf, complex *df, complex *duf, complex *du2, int *ipiv, complex *b, int *ldb, complex *x, int *ldx, float *rcond, float *ferr, float *berr, complex *work, float *rwork, int *info, int fact_len, int trans_len);
extern void CGTTRF(int *n, complex *dl, complex *d, complex *du, complex *du2, int *ipiv, int *info);
extern void CGTTRS(char *trans, int *n, int *nrhs, complex *dl, complex *d, complex *du, complex *du2, int *ipiv, complex *b, int *ldb, int *info, int trans_len);
extern void CHBEV(char *jobz, char *uplo, int *n, int *kd, complex *ab, int *ldab, float *w, complex *z, int *ldz, complex *work, float *rwork, int *info, int jobz_len, int uplo_len);
extern void CHBEVD(char *jobz, char *uplo, int *n, int *kd, complex *ab, int *ldab, float *w, complex *z, int *ldz, complex *work, int *lwork, float *rwork, int *lrwork, int *iwork, int *liwork, int *info, int jobz_len, int uplo_len);
extern void CHBEVX(char *jobz, char *range, char *uplo, int *n, int *kd, complex *ab, int *ldab, complex *q, int *ldq, float *vl, float *vu, int *il, int *iu, float *abstol, int *m, float *w, complex *z, int *ldz, complex *work, float *rwork, int *iwork, int *ifail, int *info, int jobz_len, int range_len, int uplo_len);
extern void CHBGST(char *vect, char *uplo, int *n, int *ka, int *kb, complex *ab, int *ldab, complex *bb, int *ldbb, complex *x, int *ldx, complex *work, float *rwork, int *info, int vect_len, int uplo_len);
extern void CHBGV(char *jobz, char *uplo, int *n, int *ka, int *kb, complex *ab, int *ldab, complex *bb, int *ldbb, float *w, complex *z, int *ldz, complex *work, float *rwork, int *info, int jobz_len, int uplo_len);
extern void CHBGVD(char *jobz, char *uplo, int *n, int *ka, int *kb, complex *ab, int *ldab, complex *bb, int *ldbb, float *w, complex *z, int *ldz, complex *work, int *lwork, float *rwork, int *lrwork, int *iwork, int *liwork, int *info, int jobz_len, int uplo_len);
extern void CHBGVX(char *jobz, char *range, char *uplo, int *n, int *ka, int *kb, complex *ab, int *ldab, complex *bb, int *ldbb, complex *q, int *ldq, float *vl, float *vu, int *il, int *iu, float *abstol, int *m, float *w, complex *z, int *ldz, complex *work, float *rwork, int *iwork, int *ifail, int *info, int jobz_len, int range_len, int uplo_len);
extern void CHBTRD(char *vect, char *uplo, int *n, int *kd, complex *ab, int *ldab, float *d, float *e, complex *q, int *ldq, complex *work, int *info, int vect_len, int uplo_len);
extern void CHECON(char *uplo, int *n, complex *a, int *lda, int *ipiv, float *anorm, float *rcond, complex *work, int *info, int uplo_len);
extern void CHEEV(char *jobz, char *uplo, int *n, complex *a, int *lda, float *w, complex *work, int *lwork, float *rwork, int *info, int jobz_len, int uplo_len);
extern void CHEEVD(char *jobz, char *uplo, int *n, complex *a, int *lda, float *w, complex *work, int *lwork, float *rwork, int *lrwork, int *iwork, int *liwork, int *info, int jobz_len, int uplo_len);
extern void CHEEVR(char *jobz, char *range, char *uplo, int *n, complex *a, int *lda, float *vl, float *vu, int *il, int *iu, float *abstol, int *m, float *w, complex *z, int *ldz, int *isuppz, complex *work, int *lwork, float *rwork, int *lrwork, int *iwork, int *liwork, int *info, int jobz_len, int range_len, int uplo_len);
extern void CHEEVX(char *jobz, char *range, char *uplo, int *n, complex *a, int *lda, float *vl, float *vu, int *il, int *iu, float *abstol, int *m, float *w, complex *z, int *ldz, complex *work, int *lwork, float *rwork, int *iwork, int *ifail, int *info, int jobz_len, int range_len, int uplo_len);
extern void CHEGST(int *itype, char *uplo, int *n, complex *a, int *lda, complex *b, int *ldb, int *info, int uplo_len);
extern void CHEGV(int *itype, char *jobz, char *uplo, int *n, complex *a, int *lda, complex *b, int *ldb, float *w, complex *work, int *lwork, float *rwork, int *info, int jobz_len, int uplo_len);
extern void CHEGVD(int *itype, char *jobz, char *uplo, int *n, complex *a, int *lda, complex *b, int *ldb, float *w, complex *work, int *lwork, float *rwork, int *lrwork, int *iwork, int *liwork, int *info, int jobz_len, int uplo_len);
extern void CHEGVX(int *itype, char *jobz, char *range, char *uplo, int *n, complex *a, int *lda, complex *b, int *ldb, float *vl, float *vu, int *il, int *iu, float *abstol, int *m, float *w, complex *z, int *ldz, complex *work, int *lwork, float *rwork, int *iwork, int *ifail, int *info, int jobz_len, int range_len, int uplo_len);
extern void CHERFS(char *uplo, int *n, int *nrhs, complex *a, int *lda, complex *af, int *ldaf, int *ipiv, complex *b, int *ldb, complex *x, int *ldx, float *ferr, float *berr, complex *work, float *rwork, int *info, int uplo_len);
extern void CHESV(char *uplo, int *n, int *nrhs, complex *a, int *lda, int *ipiv, complex *b, int *ldb, complex *work, int *lwork, int *info, int uplo_len);
extern void CHESVX(char *fact, char *uplo, int *n, int *nrhs, complex *a, int *lda, complex *af, int *ldaf, int *ipiv, complex *b, int *ldb, complex *x, int *ldx, float *rcond, float *ferr, float *berr, complex *work, int *lwork, float *rwork, int *info, int fact_len, int uplo_len);
extern void CHETRD(char *uplo, int *n, complex *a, int *lda, float *d, float *e, complex *tau, complex *work, int *lwork, int *info, int uplo_len);
extern void CHETRF(char *uplo, int *n, complex *a, int *lda, int *ipiv, complex *work, int *lwork, int *info, int uplo_len);
extern void CHETRI(char *uplo, int *n, complex *a, int *lda, int *ipiv, complex *work, int *info, int uplo_len);
extern void CHETRS(char *uplo, int *n, int *nrhs, complex *a, int *lda, int *ipiv, complex *b, int *ldb, int *info, int uplo_len);
extern void CHGEQZ(char *job, char *compq, char *compz, int *n, int *ilo, int *ihi, complex *a, int *lda, complex *b, int *ldb, complex *alpha, complex *beta, complex *q, int *ldq, complex *z, int *ldz, complex *work, int *lwork, float *rwork, int *info, int job_len, int compq_len, int compz_len);
extern void CHPCON(char *uplo, int *n, complex *ap, int *ipiv, float *anorm, float *rcond, complex *work, int *info, int uplo_len);
extern void CHPEV(char *jobz, char *uplo, int *n, complex *ap, float *w, complex *z, int *ldz, complex *work, float *rwork, int *info, int jobz_len, int uplo_len);
extern void CHPEVD(char *jobz, char *uplo, int *n, complex *ap, float *w, complex *z, int *ldz, complex *work, int *lwork, float *rwork, int *lrwork, int *iwork, int *liwork, int *info, int jobz_len, int uplo_len);
extern void CHPEVX(char *jobz, char *range, char *uplo, int *n, complex *ap, float *vl, float *vu, int *il, int *iu, float *abstol, int *m, float *w, complex *z, int *ldz, complex *work, float *rwork, int *iwork, int *ifail, int *info, int jobz_len, int range_len, int uplo_len);
extern void CHPGST(int *itype, char *uplo, int *n, complex *ap, complex *bp, int *info, int uplo_len);
extern void CHPGV(int *itype, char *jobz, char *uplo, int *n, complex *ap, complex *bp, float *w, complex *z, int *ldz, complex *work, float *rwork, int *info, int jobz_len, int uplo_len);
extern void CHPGVD(int *itype, char *jobz, char *uplo, int *n, complex *ap, complex *bp, float *w, complex *z, int *ldz, complex *work, int *lwork, float *rwork, int *lrwork, int *iwork, int *liwork, int *info, int jobz_len, int uplo_len);
extern void CHPGVX(int *itype, char *jobz, char *range, char *uplo, int *n, complex *ap, complex *bp, float *vl, float *vu, int *il, int *iu, float *abstol, int *m, float *w, complex *z, int *ldz, complex *work, float *rwork, int *iwork, int *ifail, int *info, int jobz_len, int range_len, int uplo_len);
extern void CHPRFS(char *uplo, int *n, int *nrhs, complex *ap, complex *afp, int *ipiv, complex *b, int *ldb, complex *x, int *ldx, float *ferr, float *berr, complex *work, float *rwork, int *info, int uplo_len);
extern void CHPSV(char *uplo, int *n, int *nrhs, complex *ap, int *ipiv, complex *b, int *ldb, int *info, int uplo_len);
extern void CHPSVX(char *fact, char *uplo, int *n, int *nrhs, complex *ap, complex *afp, int *ipiv, complex *b, int *ldb, complex *x, int *ldx, float *rcond, float *ferr, float *berr, complex *work, float *rwork, int *info, int fact_len, int uplo_len);
extern void CHPTRD(char *uplo, int *n, complex *ap, float *d, float *e, complex *tau, int *info, int uplo_len);
extern void CHPTRF(char *uplo, int *n, complex *ap, int *ipiv, int *info, int uplo_len);
extern void CHPTRI(char *uplo, int *n, complex *ap, int *ipiv, complex *work, int *info, int uplo_len);
extern void CHPTRS(char *uplo, int *n, int *nrhs, complex *ap, int *ipiv, complex *b, int *ldb, int *info, int uplo_len);
extern void CHSEIN(char *side, char *eigsrc, char *initv, int *select, int *n, complex *h, int *ldh, complex *w, complex *vl, int *ldvl, complex *vr, int *ldvr, int *mm, int *m, complex *work, float *rwork, int *ifaill, int *ifailr, int *info, int side_len, int eigsrc_len, int initv_len);
extern void CHSEQR(char *job, char *compz, int *n, int *ilo, int *ihi, complex *h, int *ldh, complex *w, complex *z, int *ldz, complex *work, int *lwork, int *info, int job_len, int compz_len);
extern void CPBCON(char *uplo, int *n, int *kd, complex *ab, int *ldab, float *anorm, float *rcond, complex *work, float *rwork, int *info, int uplo_len);
extern void CPBEQU(char *uplo, int *n, int *kd, complex *ab, int *ldab, float *s, float *scond, float *amax, int *info, int uplo_len);
extern void CPBRFS(char *uplo, int *n, int *kd, int *nrhs, complex *ab, int *ldab, complex *afb, int *ldafb, complex *b, int *ldb, complex *x, int *ldx, float *ferr, float *berr, complex *work, float *rwork, int *info, int uplo_len);
extern void CPBSTF(char *uplo, int *n, int *kd, complex *ab, int *ldab, int *info, int uplo_len);
extern void CPBSV(char *uplo, int *n, int *kd, int *nrhs, complex *ab, int *ldab, complex *b, int *ldb, int *info, int uplo_len);
extern void CPBSVX(char *fact, char *uplo, int *n, int *kd, int *nrhs, complex *ab, int *ldab, complex *afb, int *ldafb, char *equed, float *s, complex *b, int *ldb, complex *x, int *ldx, float *rcond, float *ferr, float *berr, complex *work, float *rwork, int *info, int fact_len, int uplo_len, int equed_len);
extern void CPBTRF(char *uplo, int *n, int *kd, complex *ab, int *ldab, int *info, int uplo_len);
extern void CPBTRS(char *uplo, int *n, int *kd, int *nrhs, complex *ab, int *ldab, complex *b, int *ldb, int *info, int uplo_len);
extern void CPOCON(char *uplo, int *n, complex *a, int *lda, float *anorm, float *rcond, complex *work, float *rwork, int *info, int uplo_len);
extern void CPOEQU(int *n, complex *a, int *lda, float *s, float *scond, float *amax, int *info);
extern void CPORFS(char *uplo, int *n, int *nrhs, complex *a, int *lda, complex *af, int *ldaf, complex *b, int *ldb, complex *x, int *ldx, float *ferr, float *berr, complex *work, float *rwork, int *info, int uplo_len);
extern void CPOSV(char *uplo, int *n, int *nrhs, complex *a, int *lda, complex *b, int *ldb, int *info, int uplo_len);
extern void CPOSVX(char *fact, char *uplo, int *n, int *nrhs, complex *a, int *lda, complex *af, int *ldaf, char *equed, float *s, complex *b, int *ldb, complex *x, int *ldx, float *rcond, float *ferr, float *berr, complex *work, float *rwork, int *info, int fact_len, int uplo_len, int equed_len);
extern void CPOTRF(char *uplo, int *n, complex *a, int *lda, int *info, int uplo_len);
extern void CPOTRI(char *uplo, int *n, complex *a, int *lda, int *info, int uplo_len);
extern void CPOTRS(char *uplo, int *n, int *nrhs, complex *a, int *lda, complex *b, int *ldb, int *info, int uplo_len);
extern void CPPCON(char *uplo, int *n, complex *ap, float *anorm, float *rcond, complex *work, float *rwork, int *info, int uplo_len);
extern void CPPEQU(char *uplo, int *n, complex *ap, float *s, float *scond, float *amax, int *info, int uplo_len);
extern void CPPRFS(char *uplo, int *n, int *nrhs, complex *ap, complex *afp, complex *b, int *ldb, complex *x, int *ldx, float *ferr, float *berr, complex *work, float *rwork, int *info, int uplo_len);
extern void CPPSV(char *uplo, int *n, int *nrhs, complex *ap, complex *b, int *ldb, int *info, int uplo_len);
extern void CPPSVX(char *fact, char *uplo, int *n, int *nrhs, complex *ap, complex *afp, char *equed, float *s, complex *b, int *ldb, complex *x, int *ldx, float *rcond, float *ferr, float *berr, complex *work, float *rwork, int *info, int fact_len, int uplo_len, int equed_len);
extern void CPPTRF(char *uplo, int *n, complex *ap, int *info, int uplo_len);
extern void CPPTRI(char *uplo, int *n, complex *ap, int *info, int uplo_len);
extern void CPPTRS(char *uplo, int *n, int *nrhs, complex *ap, complex *b, int *ldb, int *info, int uplo_len);
extern void CPTCON(int *n, float *d, complex *e, float *anorm, float *rcond, float *rwork, int *info);
extern void CPTEQR(char *compz, int *n, float *d, float *e, complex *z, int *ldz, float *work, int *info, int compz_len);
extern void CPTRFS(char *uplo, int *n, int *nrhs, float *d, complex *e, float *df, complex *ef, complex *b, int *ldb, complex *x, int *ldx, float *ferr, float *berr, complex *work, float *rwork, int *info, int uplo_len);
extern void CPTSV(int *n, int *nrhs, float *d, complex *e, complex *b, int *ldb, int *info);
extern void CPTSVX(char *fact, int *n, int *nrhs, float *d, complex *e, float *df, complex *ef, complex *b, int *ldb, complex *x, int *ldx, float *rcond, float *ferr, float *berr, complex *work, float *rwork, int *info, int fact_len);
extern void CPTTRF(int *n, float *d, complex *e, int *info);
extern void CPTTRS(char *uplo, int *n, int *nrhs, float *d, complex *e, complex *b, int *ldb, int *info, int uplo_len);
extern void CSPCON(char *uplo, int *n, complex *ap, int *ipiv, float *anorm, float *rcond, complex *work, int *info, int uplo_len);
extern void CSPRFS(char *uplo, int *n, int *nrhs, complex *ap, complex *afp, int *ipiv, complex *b, int *ldb, complex *x, int *ldx, float *ferr, float *berr, complex *work, float *rwork, int *info, int uplo_len);
extern void CSPSV(char *uplo, int *n, int *nrhs, complex *ap, int *ipiv, complex *b, int *ldb, int *info, int uplo_len);
extern void CSPSVX(char *fact, char *uplo, int *n, int *nrhs, complex *ap, complex *afp, int *ipiv, complex *b, int *ldb, complex *x, int *ldx, float *rcond, float *ferr, float *berr, complex *work, float *rwork, int *info, int fact_len, int uplo_len);
extern void CSPTRF(char *uplo, int *n, complex *ap, int *ipiv, int *info, int uplo_len);
extern void CSPTRI(char *uplo, int *n, complex *ap, int *ipiv, complex *work, int *info, int uplo_len);
extern void CSPTRS(char *uplo, int *n, int *nrhs, complex *ap, int *ipiv, complex *b, int *ldb, int *info, int uplo_len);
extern void CSTEDC(char *compz, int *n, float *d, float *e, complex *z, int *ldz, complex *work, int *lwork, float *rwork, int *lrwork, int *iwork, int *liwork, int *info, int compz_len);
extern void CSTEGR(char *jobz, char *range, int *n, float *d, float *e, float *vl, float *vu, int *il, int *iu, float *abstol, int *m, float *w, complex *z, int *ldz, int *isuppz, float *work, int *lwork, int *iwork, int *liwork, int *info, int jobz_len, int range_len);
extern void CSTEIN(int *n, float *d, float *e, int *m, float *w, int *iblock, int *isplit, complex *z, int *ldz, float *work, int *iwork, int *ifail, int *info);
extern void CSTEQR(char *compz, int *n, float *d, float *e, complex *z, int *ldz, float *work, int *info, int compz_len);
extern void CSYCON(char *uplo, int *n, complex *a, int *lda, int *ipiv, float *anorm, float *rcond, complex *work, int *info, int uplo_len);
extern void CSYRFS(char *uplo, int *n, int *nrhs, complex *a, int *lda, complex *af, int *ldaf, int *ipiv, complex *b, int *ldb, complex *x, int *ldx, float *ferr, float *berr, complex *work, float *rwork, int *info, int uplo_len);
extern void CSYSV(char *uplo, int *n, int *nrhs, complex *a, int *lda, int *ipiv, complex *b, int *ldb, complex *work, int *lwork, int *info, int uplo_len);
extern void CSYSVX(char *fact, char *uplo, int *n, int *nrhs, complex *a, int *lda, complex *af, int *ldaf, int *ipiv, complex *b, int *ldb, complex *x, int *ldx, float *rcond, float *ferr, float *berr, complex *work, int *lwork, float *rwork, int *info, int fact_len, int uplo_len);
extern void CSYTRF(char *uplo, int *n, complex *a, int *lda, int *ipiv, complex *work, int *lwork, int *info, int uplo_len);
extern void CSYTRI(char *uplo, int *n, complex *a, int *lda, int *ipiv, complex *work, int *info, int uplo_len);
extern void CSYTRS(char *uplo, int *n, int *nrhs, complex *a, int *lda, int *ipiv, complex *b, int *ldb, int *info, int uplo_len);
extern void CTBCON(char *norm, char *uplo, char *diag, int *n, int *kd, complex *ab, int *ldab, float *rcond, complex *work, float *rwork, int *info, int norm_len, int uplo_len, int diag_len);
extern void CTBRFS(char *uplo, char *trans, char *diag, int *n, int *kd, int *nrhs, complex *ab, int *ldab, complex *b, int *ldb, complex *x, int *ldx, float *ferr, float *berr, complex *work, float *rwork, int *info, int uplo_len, int trans_len, int diag_len);
extern void CTBTRS(char *uplo, char *trans, char *diag, int *n, int *kd, int *nrhs, complex *ab, int *ldab, complex *b, int *ldb, int *info, int uplo_len, int trans_len, int diag_len);
extern void CTGEVC(char *side, char *howmny, int *select, int *n, complex *a, int *lda, complex *b, int *ldb, complex *vl, int *ldvl, complex *vr, int *ldvr, int *mm, int *m, complex *work, float *rwork, int *info, int side_len, int howmny_len);
extern void CTGEXC(int *wantq, int *wantz, int *n, complex *a, int *lda, complex *b, int *ldb, complex *q, int *ldq, complex *z, int *ldz, int *ifst, int *ilst, int *info);
extern void CTGSEN(int *ijob, int *wantq, int *wantz, int *select, int *n, complex *a, int *lda, complex *b, int *ldb, complex *alpha, complex *beta, complex *q, int *ldq, complex *z, int *ldz, int *m, float *pl, float *pr, float *dif, complex *work, int *lwork, int *iwork, int *liwork, int *info);
extern void CTGSJA(char *jobu, char *jobv, char *jobq, int *m, int *p, int *n, int *k, int *l, complex *a, int *lda, complex *b, int *ldb, float *tola, float *tolb, float *alpha, float *beta, complex *u, int *ldu, complex *v, int *ldv, complex *q, int *ldq, complex *work, int *ncycle, int *info, int jobu_len, int jobv_len, int jobq_len);
extern void CTGSNA(char *job, char *howmny, int *select, int *n, complex *a, int *lda, complex *b, int *ldb, complex *vl, int *ldvl, complex *vr, int *ldvr, float *s, float *dif, int *mm, int *m, complex *work, int *lwork, int *iwork, int *info, int job_len, int howmny_len);
extern void CTGSYL(char *trans, int *ijob, int *m, int *n, complex *a, int *lda, complex *b, int *ldb, complex *c, int *ldc, complex *d, int *ldd, complex *e, int *lde, complex *f, int *ldf, float *scale, float *dif, complex *work, int *lwork, int *iwork, int *info, int trans_len);
extern void CTPCON(char *norm, char *uplo, char *diag, int *n, complex *ap, float *rcond, complex *work, float *rwork, int *info, int norm_len, int uplo_len, int diag_len);
extern void CTPRFS(char *uplo, char *trans, char *diag, int *n, int *nrhs, complex *ap, complex *b, int *ldb, complex *x, int *ldx, float *ferr, float *berr, complex *work, float *rwork, int *info, int uplo_len, int trans_len, int diag_len);
extern void CTPTRI(char *uplo, char *diag, int *n, complex *ap, int *info, int uplo_len, int diag_len);
extern void CTPTRS(char *uplo, char *trans, char *diag, int *n, int *nrhs, complex *ap, complex *b, int *ldb, int *info, int uplo_len, int trans_len, int diag_len);
extern void CTRCON(char *norm, char *uplo, char *diag, int *n, complex *a, int *lda, float *rcond, complex *work, float *rwork, int *info, int norm_len, int uplo_len, int diag_len);
extern void CTREVC(char *side, char *howmny, int *select, int *n, complex *t, int *ldt, complex *vl, int *ldvl, complex *vr, int *ldvr, int *mm, int *m, complex *work, float *rwork, int *info, int side_len, int howmny_len);
extern void CTREXC(char *compq, int *n, complex *t, int *ldt, complex *q, int *ldq, int *ifst, int *ilst, int *info, int compq_len);
extern void CTRRFS(char *uplo, char *trans, char *diag, int *n, int *nrhs, complex *a, int *lda, complex *b, int *ldb, complex *x, int *ldx, float *ferr, float *berr, complex *work, float *rwork, int *info, int uplo_len, int trans_len, int diag_len);
extern void CTRSEN(char *job, char *compq, int *select, int *n, complex *t, int *ldt, complex *q, int *ldq, complex *w, int *m, float *s, float *sep, complex *work, int *lwork, int *info, int job_len, int compq_len);
extern void CTRSNA(char *job, char *howmny, int *select, int *n, complex *t, int *ldt, complex *vl, int *ldvl, complex *vr, int *ldvr, float *s, float *sep, int *mm, int *m, complex *work, int *ldwork, float *rwork, int *info, int job_len, int howmny_len);
extern void CTRSYL(char *trana, char *tranb, int *isgn, int *m, int *n, complex *a, int *lda, complex *b, int *ldb, complex *c, int *ldc, float *scale, int *info, int trana_len, int tranb_len);
extern void CTRTRI(char *uplo, char *diag, int *n, complex *a, int *lda, int *info, int uplo_len, int diag_len);
extern void CTRTRS(char *uplo, char *trans, char *diag, int *n, int *nrhs, complex *a, int *lda, complex *b, int *ldb, int *info, int uplo_len, int trans_len, int diag_len);
extern void CTZRQF(int *m, int *n, complex *a, int *lda, complex *tau, int *info);
extern void CTZRZF(int *m, int *n, complex *a, int *lda, complex *tau, complex *work, int *lwork, int *info);
extern void CUNGBR(char *vect, int *m, int *n, int *k, complex *a, int *lda, complex *tau, complex *work, int *lwork, int *info, int vect_len);
extern void CUNGHR(int *n, int *ilo, int *ihi, complex *a, int *lda, complex *tau, complex *work, int *lwork, int *info);
extern void CUNGLQ(int *m, int *n, int *k, complex *a, int *lda, complex *tau, complex *work, int *lwork, int *info);
extern void CUNGQL(int *m, int *n, int *k, complex *a, int *lda, complex *tau, complex *work, int *lwork, int *info);
extern void CUNGQR(int *m, int *n, int *k, complex *a, int *lda, complex *tau, complex *work, int *lwork, int *info);
extern void CUNGRQ(int *m, int *n, int *k, complex *a, int *lda, complex *tau, complex *work, int *lwork, int *info);
extern void CUNGTR(char *uplo, int *n, complex *a, int *lda, complex *tau, complex *work, int *lwork, int *info, int uplo_len);
extern void CUNMBR(char *vect, char *side, char *trans, int *m, int *n, int *k, complex *a, int *lda, complex *tau, complex *c, int *ldc, complex *work, int *lwork, int *info, int vect_len, int side_len, int trans_len);
extern void CUNMHR(char *side, char *trans, int *m, int *n, int *ilo, int *ihi, complex *a, int *lda, complex *tau, complex *c, int *ldc, complex *work, int *lwork, int *info, int side_len, int trans_len);
extern void CUNMLQ(char *side, char *trans, int *m, int *n, int *k, complex *a, int *lda, complex *tau, complex *c, int *ldc, complex *work, int *lwork, int *info, int side_len, int trans_len);
extern void CUNMQL(char *side, char *trans, int *m, int *n, int *k, complex *a, int *lda, complex *tau, complex *c, int *ldc, complex *work, int *lwork, int *info, int side_len, int trans_len);
extern void CUNMQR(char *side, char *trans, int *m, int *n, int *k, complex *a, int *lda, complex *tau, complex *c, int *ldc, complex *work, int *lwork, int *info, int side_len, int trans_len);
extern void CUNMR3(char *side, char *trans, int *m, int *n, int *k, int *l, complex *a, int *lda, complex *tau, complex *c, int *ldc, complex *work, int *info, int side_len, int trans_len);
extern void CUNMRQ(char *side, char *trans, int *m, int *n, int *k, complex *a, int *lda, complex *tau, complex *c, int *ldc, complex *work, int *lwork, int *info, int side_len, int trans_len);
extern void CUNMRZ(char *side, char *trans, int *m, int *n, int *k, int *l, complex *a, int *lda, complex *tau, complex *c, int *ldc, complex *work, int *lwork, int *info, int side_len, int trans_len);
extern void CUNMTR(char *side, char *uplo, char *trans, int *m, int *n, complex *a, int *lda, complex *tau, complex *c, int *ldc, complex *work, int *lwork, int *info, int side_len, int uplo_len, int trans_len);
extern void CUPGTR(char *uplo, int *n, complex *ap, complex *tau, complex *q, int *ldq, complex *work, int *info, int uplo_len);
extern void CUPMTR(char *side, char *uplo, char *trans, int *m, int *n, complex *ap, complex *tau, complex *c, int *ldc, complex *work, int *info, int side_len, int uplo_len, int trans_len);
extern void DBDSDC(char *uplo, char *compq, int *n, double *d, double *e, double *u, int *ldu, double *vt, int *ldvt, double *q, int *iq, double *work, int *iwork, int *info, int uplo_len, int compq_len);
extern void DBDSQR(char *uplo, int *n, int *ncvt, int *nru, int *ncc, double *d, double *e, double *vt, int *ldvt, double *u, int *ldu, double *c, int *ldc, double *work, int *info, int uplo_len);
extern void DDISNA(char *job, int *m, int *n, double *d, double *sep, int *info, int job_len);
extern void DGBBRD(char *vect, int *m, int *n, int *ncc, int *kl, int *ku, double *ab, int *ldab, double *d, double *e, double *q, int *ldq, double *pt, int *ldpt, double *c, int *ldc, double *work, int *info, int vect_len);
extern void DGBCON(char *norm, int *n, int *kl, int *ku, double *ab, int *ldab, int *ipiv, double *anorm, double *rcond, double *work, int *iwork, int *info, int norm_len);
extern void DGBEQU(int *m, int *n, int *kl, int *ku, double *ab, int *ldab, double *r, double *c, double *rowcnd, double *colcnd, double *amax, int *info);
extern void DGBRFS(char *trans, int *n, int *kl, int *ku, int *nrhs, double *ab, int *ldab, double *afb, int *ldafb, int *ipiv, double *b, int *ldb, double *x, int *ldx, double *ferr, double *berr, double *work, int *iwork, int *info, int trans_len);
extern void DGBSV(int *n, int *kl, int *ku, int *nrhs, double *ab, int *ldab, int *ipiv, double *b, int *ldb, int *info);
extern void DGBSVX(char *fact, char *trans, int *n, int *kl, int *ku, int *nrhs, double *ab, int *ldab, double *afb, int *ldafb, int *ipiv, char *equed, double *r, double *c, double *b, int *ldb, double *x, int *ldx, double *rcond, double *ferr, double *berr, double *work, int *iwork, int *info, int fact_len, int trans_len, int equed_len);
extern void DGBTRF(int *m, int *n, int *kl, int *ku, double *ab, int *ldab, int *ipiv, int *info);
extern void DGBTRS(char *trans, int *n, int *kl, int *ku, int *nrhs, double *ab, int *ldab, int *ipiv, double *b, int *ldb, int *info, int trans_len);
extern void DGEBAK(char *job, char *side, int *n, int *ilo, int *ihi, double *scale, int *m, double *v, int *ldv, int *info, int job_len, int side_len);
extern void DGEBAL(char *job, int *n, double *a, int *lda, int *ilo, int *ihi, double *scale, int *info, int job_len);
extern void DGEBRD(int *m, int *n, double *a, int *lda, double *d, double *e, double *tauq, double *taup, double *work, int *lwork, int *info);
extern void DGECON(char *norm, int *n, double *a, int *lda, double *anorm, double *rcond, double *work, int *iwork, int *info, int norm_len);
extern void DGEEQU(int *m, int *n, double *a, int *lda, double *r, double *c, double *rowcnd, double *colcnd, double *amax, int *info);
extern void DGEES(char *jobvs, char *sort, ACML_DGEES_SELECT select, int *n, double *a, int *lda, int *sdim, double *wr, double *wi, double *vs, int *ldvs, double *work, int *lwork, int *bwork, int *info, int jobvs_len, int sort_len);
extern void DGEESX(char *jobvs, char *sort, ACML_DGEESX_SELECT select, char *sense, int *n, double *a, int *lda, int *sdim, double *wr, double *wi, double *vs, int *ldvs, double *rconde, double *rcondv, double *work, int *lwork, int *iwork, int *liwork, int *bwork, int *info, int jobvs_len, int sort_len, int sense_len);
extern void DGEEV(char *jobvl, char *jobvr, int *n, double *a, int *lda, double *wr, double *wi, double *vl, int *ldvl, double *vr, int *ldvr, double *work, int *lwork, int *info, int jobvl_len, int jobvr_len);
extern void DGEEVX(char *balanc, char *jobvl, char *jobvr, char *sense, int *n, double *a, int *lda, double *wr, double *wi, double *vl, int *ldvl, double *vr, int *ldvr, int *ilo, int *ihi, double *scale, double *abnrm, double *rconde, double *rcondv, double *work, int *lwork, int *iwork, int *info, int balanc_len, int jobvl_len, int jobvr_len, int sense_len);
extern void DGEGS(char *jobvsl, char *jobvsr, int *n, double *a, int *lda, double *b, int *ldb, double *alphar, double *alphai, double *beta, double *vsl, int *ldvsl, double *vsr, int *ldvsr, double *work, int *lwork, int *info, int jobvsl_len, int jobvsr_len);
extern void DGEGV(char *jobvl, char *jobvr, int *n, double *a, int *lda, double *b, int *ldb, double *alphar, double *alphai, double *beta, double *vl, int *ldvl, double *vr, int *ldvr, double *work, int *lwork, int *info, int jobvl_len, int jobvr_len);
extern void DGEHRD(int *n, int *ilo, int *ihi, double *a, int *lda, double *tau, double *work, int *lwork, int *info);
extern void DGELQF(int *m, int *n, double *a, int *lda, double *tau, double *work, int *lwork, int *info);
extern void DGELS(char *trans, int *m, int *n, int *nrhs, double *a, int *lda, double *b, int *ldb, double *work, int *lwork, int *info, int trans_len);
extern void DGELSD(int *m, int *n, int *nrhs, double *a, int *lda, double *b, int *ldb, double *s, double *rcond, int *rank, double *work, int *lwork, int *iwork, int *info);
extern void DGELSS(int *m, int *n, int *nrhs, double *a, int *lda, double *b, int *ldb, double *s, double *rcond, int *rank, double *work, int *lwork, int *info);
extern void DGELSX(int *m, int *n, int *nrhs, double *a, int *lda, double *b, int *ldb, int *jpvt, double *rcond, int *rank, double *work, int *info);
extern void DGELSY(int *m, int *n, int *nrhs, double *a, int *lda, double *b, int *ldb, int *jpvt, double *rcond, int *rank, double *work, int *lwork, int *info);
extern void DGEQLF(int *m, int *n, double *a, int *lda, double *tau, double *work, int *lwork, int *info);
extern void DGEQP3(int *m, int *n, double *a, int *lda, int *jpvt, double *tau, double *work, int *lwork, int *info);
extern void DGEQPF(int *m, int *n, double *a, int *lda, int *jpvt, double *tau, double *work, int *info);
extern void DGEQRF(int *m, int *n, double *a, int *lda, double *tau, double *work, int *lwork, int *info);
extern void DGERFS(char *trans, int *n, int *nrhs, double *a, int *lda, double *af, int *ldaf, int *ipiv, double *b, int *ldb, double *x, int *ldx, double *ferr, double *berr, double *work, int *iwork, int *info, int trans_len);
extern void DGERQF(int *m, int *n, double *a, int *lda, double *tau, double *work, int *lwork, int *info);
extern void DGESDD(char *jobz, int *m, int *n, double *a, int *lda, double *s, double *u, int *ldu, double *vt, int *ldvt, double *work, int *lwork, int *iwork, int *info, int jobz_len);
extern void DGESV(int *n, int *nrhs, double *a, int *lda, int *ipiv, double *b, int *ldb, int *info);
extern void DGESVD(char *jobu, char *jobvt, int *m, int *n, double *a, int *lda, double *s, double *u, int *ldu, double *vt, int *ldvt, double *work, int *lwork, int *info, int jobu_len, int jobvt_len);
extern void DGESVX(char *fact, char *trans, int *n, int *nrhs, double *a, int *lda, double *af, int *ldaf, int *ipiv, char *equed, double *r, double *c, double *b, int *ldb, double *x, int *ldx, double *rcond, double *ferr, double *berr, double *work, int *iwork, int *info, int fact_len, int trans_len, int equed_len);
extern void DGETRF(int *m, int *n, double *a, int *lda, int *ipiv, int *info);
extern void DGETRI(int *n, double *a, int *lda, int *ipiv, double *work, int *lwork, int *info);
extern void DGETRS(char *trans, int *n, int *nrhs, double *a, int *lda, int *ipiv, double *b, int *ldb, int *info, int trans_len);
extern void DGGBAK(char *job, char *side, int *n, int *ilo, int *ihi, double *lscale, double *rscale, int *m, double *v, int *ldv, int *info, int job_len, int side_len);
extern void DGGBAL(char *job, int *n, double *a, int *lda, double *b, int *ldb, int *ilo, int *ihi, double *lscale, double *rscale, double *work, int *info, int job_len);
extern void DGGES(char *jobvsl, char *jobvsr, char *sort, ACML_DGGES_DELCTG delctg, int *n, double *a, int *lda, double *b, int *ldb, int *sdim, double *alphar, double *alphai, double *beta, double *vsl, int *ldvsl, double *vsr, int *ldvsr, double *work, int *lwork, int *bwork, int *info, int jobvsl_len, int jobvsr_len, int sort_len);
extern void DGGESX(char *jobvsl, char *jobvsr, char *sort, ACML_DGGESX_DELCTG delctg, char *sense, int *n, double *a, int *lda, double *b, int *ldb, int *sdim, double *alphar, double *alphai, double *beta, double *vsl, int *ldvsl, double *vsr, int *ldvsr, double *rconde, double *rcondv, double *work, int *lwork, int *iwork, int *liwork, int *bwork, int *info, int jobvsl_len, int jobvsr_len, int sort_len, int sense_len);
extern void DGGEV(char *jobvl, char *jobvr, int *n, double *a, int *lda, double *b, int *ldb, double *alphar, double *alphai, double *beta, double *vl, int *ldvl, double *vr, int *ldvr, double *work, int *lwork, int *info, int jobvl_len, int jobvr_len);
extern void DGGEVX(char *balanc, char *jobvl, char *jobvr, char *sense, int *n, double *a, int *lda, double *b, int *ldb, double *alphar, double *alphai, double *beta, double *vl, int *ldvl, double *vr, int *ldvr, int *ilo, int *ihi, double *lscale, double *rscale, double *abnrm, double *bbnrm, double *rconde, double *rcondv, double *work, int *lwork, int *iwork, int *bwork, int *info, int balanc_len, int jobvl_len, int jobvr_len, int sense_len);
extern void DGGGLM(int *n, int *m, int *p, double *a, int *lda, double *b, int *ldb, double *d, double *x, double *y, double *work, int *lwork, int *info);
extern void DGGHRD(char *compq, char *compz, int *n, int *ilo, int *ihi, double *a, int *lda, double *b, int *ldb, double *q, int *ldq, double *z, int *ldz, int *info, int compq_len, int compz_len);
extern void DGGLSE(int *m, int *n, int *p, double *a, int *lda, double *b, int *ldb, double *c, double *d, double *x, double *work, int *lwork, int *info);
extern void DGGQRF(int *n, int *m, int *p, double *a, int *lda, double *taua, double *b, int *ldb, double *taub, double *work, int *lwork, int *info);
extern void DGGRQF(int *m, int *p, int *n, double *a, int *lda, double *taua, double *b, int *ldb, double *taub, double *work, int *lwork, int *info);
extern void DGGSVD(char *jobu, char *jobv, char *jobq, int *m, int *n, int *p, int *k, int *l, double *a, int *lda, double *b, int *ldb, double *alpha, double *beta, double *u, int *ldu, double *v, int *ldv, double *q, int *ldq, double *work, int *iwork, int *info, int jobu_len, int jobv_len, int jobq_len);
extern void DGGSVP(char *jobu, char *jobv, char *jobq, int *m, int *p, int *n, double *a, int *lda, double *b, int *ldb, double *tola, double *tolb, int *k, int *l, double *u, int *ldu, double *v, int *ldv, double *q, int *ldq, int *iwork, double *tau, double *work, int *info, int jobu_len, int jobv_len, int jobq_len);
extern void DGTCON(char *norm, int *n, double *dl, double *d, double *du, double *du2, int *ipiv, double *anorm, double *rcond, double *work, int *iwork, int *info, int norm_len);
extern void DGTRFS(char *trans, int *n, int *nrhs, double *dl, double *d, double *du, double *dlf, double *df, double *duf, double *du2, int *ipiv, double *b, int *ldb, double *x, int *ldx, double *ferr, double *berr, double *work, int *iwork, int *info, int trans_len);
extern void DGTSV(int *n, int *nrhs, double *dl, double *d, double *du, double *b, int *ldb, int *info);
extern void DGTSVX(char *fact, char *trans, int *n, int *nrhs, double *dl, double *d, double *du, double *dlf, double *df, double *duf, double *du2, int *ipiv, double *b, int *ldb, double *x, int *ldx, double *rcond, double *ferr, double *berr, double *work, int *iwork, int *info, int fact_len, int trans_len);
extern void DGTTRF(int *n, double *dl, double *d, double *du, double *du2, int *ipiv, int *info);
extern void DGTTRS(char *trans, int *n, int *nrhs, double *dl, double *d, double *du, double *du2, int *ipiv, double *b, int *ldb, int *info, int trans_len);
extern void DHGEQZ(char *job, char *compq, char *compz, int *n, int *ilo, int *ihi, double *a, int *lda, double *b, int *ldb, double *alphar, double *alphai, double *beta, double *q, int *ldq, double *z, int *ldz, double *work, int *lwork, int *info, int job_len, int compq_len, int compz_len);
extern void DHSEIN(char *side, char *eigsrc, char *initv, int *select, int *n, double *h, int *ldh, double *wr, double *wi, double *vl, int *ldvl, double *vr, int *ldvr, int *mm, int *m, double *work, int *ifaill, int *ifailr, int *info, int side_len, int eigsrc_len, int initv_len);
extern void DHSEQR(char *job, char *compz, int *n, int *ilo, int *ihi, double *h, int *ldh, double *wr, double *wi, double *z, int *ldz, double *work, int *lwork, int *info, int job_len, int compz_len);
extern int DISNAN(double *din);
extern double DLAMCH(char *cmach, int cmach_len);
extern void DLASRT(char *id, int *n, double *d, int *info, int id_len);
extern void DLASSQ(int *n, double *x, int *incx, double *scale, double *sumsq);
extern void DOPGTR(char *uplo, int *n, double *ap, double *tau, double *q, int *ldq, double *work, int *info, int uplo_len);
extern void DOPMTR(char *side, char *uplo, char *trans, int *m, int *n, double *ap, double *tau, double *c, int *ldc, double *work, int *info, int side_len, int uplo_len, int trans_len);
extern void DORGBR(char *vect, int *m, int *n, int *k, double *a, int *lda, double *tau, double *work, int *lwork, int *info, int vect_len);
extern void DORGHR(int *n, int *ilo, int *ihi, double *a, int *lda, double *tau, double *work, int *lwork, int *info);
extern void DORGLQ(int *m, int *n, int *k, double *a, int *lda, double *tau, double *work, int *lwork, int *info);
extern void DORGQL(int *m, int *n, int *k, double *a, int *lda, double *tau, double *work, int *lwork, int *info);
extern void DORGQR(int *m, int *n, int *k, double *a, int *lda, double *tau, double *work, int *lwork, int *info);
extern void DORGRQ(int *m, int *n, int *k, double *a, int *lda, double *tau, double *work, int *lwork, int *info);
extern void DORGTR(char *uplo, int *n, double *a, int *lda, double *tau, double *work, int *lwork, int *info, int uplo_len);
extern void DORMBR(char *vect, char *side, char *trans, int *m, int *n, int *k, double *a, int *lda, double *tau, double *c, int *ldc, double *work, int *lwork, int *info, int vect_len, int side_len, int trans_len);
extern void DORMHR(char *side, char *trans, int *m, int *n, int *ilo, int *ihi, double *a, int *lda, double *tau, double *c, int *ldc, double *work, int *lwork, int *info, int side_len, int trans_len);
extern void DORMLQ(char *side, char *trans, int *m, int *n, int *k, double *a, int *lda, double *tau, double *c, int *ldc, double *work, int *lwork, int *info, int side_len, int trans_len);
extern void DORMQL(char *side, char *trans, int *m, int *n, int *k, double *a, int *lda, double *tau, double *c, int *ldc, double *work, int *lwork, int *info, int side_len, int trans_len);
extern void DORMQR(char *side, char *trans, int *m, int *n, int *k, double *a, int *lda, double *tau, double *c, int *ldc, double *work, int *lwork, int *info, int side_len, int trans_len);
extern void DORMR3(char *side, char *trans, int *m, int *n, int *k, int *l, double *a, int *lda, double *tau, double *c, int *ldc, double *work, int *info, int side_len, int trans_len);
extern void DORMRQ(char *side, char *trans, int *m, int *n, int *k, double *a, int *lda, double *tau, double *c, int *ldc, double *work, int *lwork, int *info, int side_len, int trans_len);
extern void DORMRZ(char *side, char *trans, int *m, int *n, int *k, int *l, double *a, int *lda, double *tau, double *c, int *ldc, double *work, int *lwork, int *info, int side_len, int trans_len);
extern void DORMTR(char *side, char *uplo, char *trans, int *m, int *n, double *a, int *lda, double *tau, double *c, int *ldc, double *work, int *lwork, int *info, int side_len, int uplo_len, int trans_len);
extern void DPBCON(char *uplo, int *n, int *kd, double *ab, int *ldab, double *anorm, double *rcond, double *work, int *iwork, int *info, int uplo_len);
extern void DPBEQU(char *uplo, int *n, int *kd, double *ab, int *ldab, double *s, double *scond, double *amax, int *info, int uplo_len);
extern void DPBRFS(char *uplo, int *n, int *kd, int *nrhs, double *ab, int *ldab, double *afb, int *ldafb, double *b, int *ldb, double *x, int *ldx, double *ferr, double *berr, double *work, int *iwork, int *info, int uplo_len);
extern void DPBSTF(char *uplo, int *n, int *kd, double *ab, int *ldab, int *info, int uplo_len);
extern void DPBSV(char *uplo, int *n, int *kd, int *nrhs, double *ab, int *ldab, double *b, int *ldb, int *info, int uplo_len);
extern void DPBSVX(char *fact, char *uplo, int *n, int *kd, int *nrhs, double *ab, int *ldab, double *afb, int *ldafb, char *equed, double *s, double *b, int *ldb, double *x, int *ldx, double *rcond, double *ferr, double *berr, double *work, int *iwork, int *info, int fact_len, int uplo_len, int equed_len);
extern void DPBTRF(char *uplo, int *n, int *kd, double *ab, int *ldab, int *info, int uplo_len);
extern void DPBTRS(char *uplo, int *n, int *kd, int *nrhs, double *ab, int *ldab, double *b, int *ldb, int *info, int uplo_len);
extern void DPOCON(char *uplo, int *n, double *a, int *lda, double *anorm, double *rcond, double *work, int *iwork, int *info, int uplo_len);
extern void DPOEQU(int *n, double *a, int *lda, double *s, double *scond, double *amax, int *info);
extern void DPORFS(char *uplo, int *n, int *nrhs, double *a, int *lda, double *af, int *ldaf, double *b, int *ldb, double *x, int *ldx, double *ferr, double *berr, double *work, int *iwork, int *info, int uplo_len);
extern void DPOSV(char *uplo, int *n, int *nrhs, double *a, int *lda, double *b, int *ldb, int *info, int uplo_len);
extern void DPOSVX(char *fact, char *uplo, int *n, int *nrhs, double *a, int *lda, double *af, int *ldaf, char *equed, double *s, double *b, int *ldb, double *x, int *ldx, double *rcond, double *ferr, double *berr, double *work, int *iwork, int *info, int fact_len, int uplo_len, int equed_len);
extern void DPOTRF(char *uplo, int *n, double *a, int *lda, int *info, int uplo_len);
extern void DPOTRI(char *uplo, int *n, double *a, int *lda, int *info, int uplo_len);
extern void DPOTRS(char *uplo, int *n, int *nrhs, double *a, int *lda, double *b, int *ldb, int *info, int uplo_len);
extern void DPPCON(char *uplo, int *n, double *ap, double *anorm, double *rcond, double *work, int *iwork, int *info, int uplo_len);
extern void DPPEQU(char *uplo, int *n, double *ap, double *s, double *scond, double *amax, int *info, int uplo_len);
extern void DPPRFS(char *uplo, int *n, int *nrhs, double *ap, double *afp, double *b, int *ldb, double *x, int *ldx, double *ferr, double *berr, double *work, int *iwork, int *info, int uplo_len);
extern void DPPSV(char *uplo, int *n, int *nrhs, double *ap, double *b, int *ldb, int *info, int uplo_len);
extern void DPPSVX(char *fact, char *uplo, int *n, int *nrhs, double *ap, double *afp, char *equed, double *s, double *b, int *ldb, double *x, int *ldx, double *rcond, double *ferr, double *berr, double *work, int *iwork, int *info, int fact_len, int uplo_len, int equed_len);
extern void DPPTRF(char *uplo, int *n, double *ap, int *info, int uplo_len);
extern void DPPTRI(char *uplo, int *n, double *ap, int *info, int uplo_len);
extern void DPPTRS(char *uplo, int *n, int *nrhs, double *ap, double *b, int *ldb, int *info, int uplo_len);
extern void DPTCON(int *n, double *d, double *e, double *anorm, double *rcond, double *work, int *info);
extern void DPTEQR(char *compz, int *n, double *d, double *e, double *z, int *ldz, double *work, int *info, int compz_len);
extern void DPTRFS(int *n, int *nrhs, double *d, double *e, double *df, double *ef, double *b, int *ldb, double *x, int *ldx, double *ferr, double *berr, double *work, int *info);
extern void DPTSV(int *n, int *nrhs, double *d, double *e, double *b, int *ldb, int *info);
extern void DPTSVX(char *fact, int *n, int *nrhs, double *d, double *e, double *df, double *ef, double *b, int *ldb, double *x, int *ldx, double *rcond, double *ferr, double *berr, double *work, int *info, int fact_len);
extern void DPTTRF(int *n, double *d, double *e, int *info);
extern void DPTTRS(int *n, int *nrhs, double *d, double *e, double *b, int *ldb, int *info);
extern void DSBEV(char *jobz, char *uplo, int *n, int *kd, double *ab, int *ldab, double *w, double *z, int *ldz, double *work, int *info, int jobz_len, int uplo_len);
extern void DSBEVD(char *jobz, char *uplo, int *n, int *kd, double *ab, int *ldab, double *w, double *z, int *ldz, double *work, int *lwork, int *iwork, int *liwork, int *info, int jobz_len, int uplo_len);
extern void DSBEVX(char *jobz, char *range, char *uplo, int *n, int *kd, double *ab, int *ldab, double *q, int *ldq, double *vl, double *vu, int *il, int *iu, double *abstol, int *m, double *w, double *z, int *ldz, double *work, int *iwork, int *ifail, int *info, int jobz_len, int range_len, int uplo_len);
extern void DSBGST(char *vect, char *uplo, int *n, int *ka, int *kb, double *ab, int *ldab, double *bb, int *ldbb, double *x, int *ldx, double *work, int *info, int vect_len, int uplo_len);
extern void DSBGV(char *jobz, char *uplo, int *n, int *ka, int *kb, double *ab, int *ldab, double *bb, int *ldbb, double *w, double *z, int *ldz, double *work, int *info, int jobz_len, int uplo_len);
extern void DSBGVD(char *jobz, char *uplo, int *n, int *ka, int *kb, double *ab, int *ldab, double *bb, int *ldbb, double *w, double *z, int *ldz, double *work, int *lwork, int *iwork, int *liwork, int *info, int jobz_len, int uplo_len);
extern void DSBGVX(char *jobz, char *range, char *uplo, int *n, int *ka, int *kb, double *ab, int *ldab, double *bb, int *ldbb, double *q, int *ldq, double *vl, double *vu, int *il, int *iu, double *abstol, int *m, double *w, double *z, int *ldz, double *work, int *iwork, int *ifail, int *info, int jobz_len, int range_len, int uplo_len);
extern void DSBTRD(char *vect, char *uplo, int *n, int *kd, double *ab, int *ldab, double *d, double *e, double *q, int *ldq, double *work, int *info, int vect_len, int uplo_len);
extern double DSECND(void);
extern void DSGESV(int *n, int *nrhs, double *a, int *lda, int *ipiv, double *b, int *ldb, double *x, int *ldx, double *work, float *swork, int *iter, int *info);
extern void DSPCON(char *uplo, int *n, double *ap, int *ipiv, double *anorm, double *rcond, double *work, int *iwork, int *info, int uplo_len);
extern void DSPEV(char *jobz, char *uplo, int *n, double *ap, double *w, double *z, int *ldz, double *work, int *info, int jobz_len, int uplo_len);
extern void DSPEVD(char *jobz, char *uplo, int *n, double *ap, double *w, double *z, int *ldz, double *work, int *lwork, int *iwork, int *liwork, int *info, int jobz_len, int uplo_len);
extern void DSPEVX(char *jobz, char *range, char *uplo, int *n, double *ap, double *vl, double *vu, int *il, int *iu, double *abstol, int *m, double *w, double *z, int *ldz, double *work, int *iwork, int *ifail, int *info, int jobz_len, int range_len, int uplo_len);
extern void DSPGST(int *itype, char *uplo, int *n, double *ap, double *bp, int *info, int uplo_len);
extern void DSPGV(int *itype, char *jobz, char *uplo, int *n, double *ap, double *bp, double *w, double *z, int *ldz, double *work, int *info, int jobz_len, int uplo_len);
extern void DSPGVD(int *itype, char *jobz, char *uplo, int *n, double *ap, double *bp, double *w, double *z, int *ldz, double *work, int *lwork, int *iwork, int *liwork, int *info, int jobz_len, int uplo_len);
extern void DSPGVX(int *itype, char *jobz, char *range, char *uplo, int *n, double *ap, double *bp, double *vl, double *vu, int *il, int *iu, double *abstol, int *m, double *w, double *z, int *ldz, double *work, int *iwork, int *ifail, int *info, int jobz_len, int range_len, int uplo_len);
extern void DSPRFS(char *uplo, int *n, int *nrhs, double *ap, double *afp, int *ipiv, double *b, int *ldb, double *x, int *ldx, double *ferr, double *berr, double *work, int *iwork, int *info, int uplo_len);
extern void DSPSV(char *uplo, int *n, int *nrhs, double *ap, int *ipiv, double *b, int *ldb, int *info, int uplo_len);
extern void DSPSVX(char *fact, char *uplo, int *n, int *nrhs, double *ap, double *afp, int *ipiv, double *b, int *ldb, double *x, int *ldx, double *rcond, double *ferr, double *berr, double *work, int *iwork, int *info, int fact_len, int uplo_len);
extern void DSPTRD(char *uplo, int *n, double *ap, double *d, double *e, double *tau, int *info, int uplo_len);
extern void DSPTRF(char *uplo, int *n, double *ap, int *ipiv, int *info, int uplo_len);
extern void DSPTRI(char *uplo, int *n, double *ap, int *ipiv, double *work, int *info, int uplo_len);
extern void DSPTRS(char *uplo, int *n, int *nrhs, double *ap, int *ipiv, double *b, int *ldb, int *info, int uplo_len);
extern void DSTEBZ(char *range, char *order, int *n, double *vl, double *vu, int *il, int *iu, double *abstol, double *d, double *e, int *m, int *nsplit, double *w, int *iblock, int *isplit, double *work, int *iwork, int *info, int range_len, int order_len);
extern void DSTEDC(char *compz, int *n, double *d, double *e, double *z, int *ldz, double *work, int *lwork, int *iwork, int *liwork, int *info, int compz_len);
extern void DSTEGR(char *jobz, char *range, int *n, double *d, double *e, double *vl, double *vu, int *il, int *iu, double *abstol, int *m, double *w, double *z, int *ldz, int *isuppz, double *work, int *lwork, int *iwork, int *liwork, int *info, int jobz_len, int range_len);
extern void DSTEIN(int *n, double *d, double *e, int *m, double *w, int *iblock, int *isplit, double *z, int *ldz, double *work, int *iwork, int *ifail, int *info);
extern void DSTEMR(char *jobz, char *range, int *n, double *d, double *e, double *vl, double *vu, int *il, int *iu, int *m, double *w, double *z, int *ldz, int *nzc, int *isuppz, int *tryrac, double *work, int *lwork, int *iwork, int *liwork, int *info, int jobz_len, int range_len);
extern void DSTEQR(char *compz, int *n, double *d, double *e, double *z, int *ldz, double *work, int *info, int compz_len);
extern void DSTERF(int *n, double *d, double *e, int *info);
extern void DSTEV(char *jobz, int *n, double *d, double *e, double *z, int *ldz, double *work, int *info, int jobz_len);
extern void DSTEVD(char *jobz, int *n, double *d, double *e, double *z, int *ldz, double *work, int *lwork, int *iwork, int *liwork, int *info, int jobz_len);
extern void DSTEVR(char *jobz, char *range, int *n, double *d, double *e, double *vl, double *vu, int *il, int *iu, double *abstol, int *m, double *w, double *z, int *ldz, int *isuppz, double *work, int *lwork, int *iwork, int *liwork, int *info, int jobz_len, int range_len);
extern void DSTEVX(char *jobz, char *range, int *n, double *d, double *e, double *vl, double *vu, int *il, int *iu, double *abstol, int *m, double *w, double *z, int *ldz, double *work, int *iwork, int *ifail, int *info, int jobz_len, int range_len);
extern void DSYCON(char *uplo, int *n, double *a, int *lda, int *ipiv, double *anorm, double *rcond, double *work, int *iwork, int *info, int uplo_len);
extern void DSYEV(char *jobz, char *uplo, int *n, double *a, int *lda, double *w, double *work, int *lwork, int *info, int jobz_len, int uplo_len);
extern void DSYEVD(char *jobz, char *uplo, int *n, double *a, int *lda, double *w, double *work, int *lwork, int *iwork, int *liwork, int *info, int jobz_len, int uplo_len);
extern void DSYEVR(char *jobz, char *range, char *uplo, int *n, double *a, int *lda, double *vl, double *vu, int *il, int *iu, double *abstol, int *m, double *w, double *z, int *ldz, int *isuppz, double *work, int *lwork, int *iwork, int *liwork, int *info, int jobz_len, int range_len, int uplo_len);
extern void DSYEVX(char *jobz, char *range, char *uplo, int *n, double *a, int *lda, double *vl, double *vu, int *il, int *iu, double *abstol, int *m, double *w, double *z, int *ldz, double *work, int *lwork, int *iwork, int *ifail, int *info, int jobz_len, int range_len, int uplo_len);
extern void DSYGST(int *itype, char *uplo, int *n, double *a, int *lda, double *b, int *ldb, int *info, int uplo_len);
extern void DSYGV(int *itype, char *jobz, char *uplo, int *n, double *a, int *lda, double *b, int *ldb, double *w, double *work, int *lwork, int *info, int jobz_len, int uplo_len);
extern void DSYGVD(int *itype, char *jobz, char *uplo, int *n, double *a, int *lda, double *b, int *ldb, double *w, double *work, int *lwork, int *iwork, int *liwork, int *info, int jobz_len, int uplo_len);
extern void DSYGVX(int *itype, char *jobz, char *range, char *uplo, int *n, double *a, int *lda, double *b, int *ldb, double *vl, double *vu, int *il, int *iu, double *abstol, int *m, double *w, double *z, int *ldz, double *work, int *lwork, int *iwork, int *ifail, int *info, int jobz_len, int range_len, int uplo_len);
extern void DSYRFS(char *uplo, int *n, int *nrhs, double *a, int *lda, double *af, int *ldaf, int *ipiv, double *b, int *ldb, double *x, int *ldx, double *ferr, double *berr, double *work, int *iwork, int *info, int uplo_len);
extern void DSYSV(char *uplo, int *n, int *nrhs, double *a, int *lda, int *ipiv, double *b, int *ldb, double *work, int *lwork, int *info, int uplo_len);
extern void DSYSVX(char *fact, char *uplo, int *n, int *nrhs, double *a, int *lda, double *af, int *ldaf, int *ipiv, double *b, int *ldb, double *x, int *ldx, double *rcond, double *ferr, double *berr, double *work, int *lwork, int *iwork, int *info, int fact_len, int uplo_len);
extern void DSYTRD(char *uplo, int *n, double *a, int *lda, double *d, double *e, double *tau, double *work, int *lwork, int *info, int uplo_len);
extern void DSYTRF(char *uplo, int *n, double *a, int *lda, int *ipiv, double *work, int *lwork, int *info, int uplo_len);
extern void DSYTRI(char *uplo, int *n, double *a, int *lda, int *ipiv, double *work, int *info, int uplo_len);
extern void DSYTRS(char *uplo, int *n, int *nrhs, double *a, int *lda, int *ipiv, double *b, int *ldb, int *info, int uplo_len);
extern void DTBCON(char *norm, char *uplo, char *diag, int *n, int *kd, double *ab, int *ldab, double *rcond, double *work, int *iwork, int *info, int norm_len, int uplo_len, int diag_len);
extern void DTBRFS(char *uplo, char *trans, char *diag, int *n, int *kd, int *nrhs, double *ab, int *ldab, double *b, int *ldb, double *x, int *ldx, double *ferr, double *berr, double *work, int *iwork, int *info, int uplo_len, int trans_len, int diag_len);
extern void DTBTRS(char *uplo, char *trans, char *diag, int *n, int *kd, int *nrhs, double *ab, int *ldab, double *b, int *ldb, int *info, int uplo_len, int trans_len, int diag_len);
extern void DTGEVC(char *side, char *howmny, int *select, int *n, double *a, int *lda, double *b, int *ldb, double *vl, int *ldvl, double *vr, int *ldvr, int *mm, int *m, double *work, int *info, int side_len, int howmny_len);
extern void DTGEXC(int *wantq, int *wantz, int *n, double *a, int *lda, double *b, int *ldb, double *q, int *ldq, double *z, int *ldz, int *ifst, int *ilst, double *work, int *lwork, int *info);
extern void DTGSEN(int *ijob, int *wantq, int *wantz, int *select, int *n, double *a, int *lda, double *b, int *ldb, double *alphar, double *alphai, double *beta, double *q, int *ldq, double *z, int *ldz, int *m, double *pl, double *pr, double *dif, double *work, int *lwork, int *iwork, int *liwork, int *info);
extern void DTGSJA(char *jobu, char *jobv, char *jobq, int *m, int *p, int *n, int *k, int *l, double *a, int *lda, double *b, int *ldb, double *tola, double *tolb, double *alpha, double *beta, double *u, int *ldu, double *v, int *ldv, double *q, int *ldq, double *work, int *ncycle, int *info, int jobu_len, int jobv_len, int jobq_len);
extern void DTGSNA(char *job, char *howmny, int *select, int *n, double *a, int *lda, double *b, int *ldb, double *vl, int *ldvl, double *vr, int *ldvr, double *s, double *dif, int *mm, int *m, double *work, int *lwork, int *iwork, int *info, int job_len, int howmny_len);
extern void DTGSYL(char *trans, int *ijob, int *m, int *n, double *a, int *lda, double *b, int *ldb, double *c, int *ldc, double *d, int *ldd, double *e, int *lde, double *f, int *ldf, double *scale, double *dif, double *work, int *lwork, int *iwork, int *info, int trans_len);
extern void DTPCON(char *norm, char *uplo, char *diag, int *n, double *ap, double *rcond, double *work, int *iwork, int *info, int norm_len, int uplo_len, int diag_len);
extern void DTPRFS(char *uplo, char *trans, char *diag, int *n, int *nrhs, double *ap, double *b, int *ldb, double *x, int *ldx, double *ferr, double *berr, double *work, int *iwork, int *info, int uplo_len, int trans_len, int diag_len);
extern void DTPTRI(char *uplo, char *diag, int *n, double *ap, int *info, int uplo_len, int diag_len);
extern void DTPTRS(char *uplo, char *trans, char *diag, int *n, int *nrhs, double *ap, double *b, int *ldb, int *info, int uplo_len, int trans_len, int diag_len);
extern void DTRCON(char *norm, char *uplo, char *diag, int *n, double *a, int *lda, double *rcond, double *work, int *iwork, int *info, int norm_len, int uplo_len, int diag_len);
extern void DTREVC(char *side, char *howmny, int *select, int *n, double *t, int *ldt, double *vl, int *ldvl, double *vr, int *ldvr, int *mm, int *m, double *work, int *info, int side_len, int howmny_len);
extern void DTREXC(char *compq, int *n, double *t, int *ldt, double *q, int *ldq, int *ifst, int *ilst, double *work, int *info, int compq_len);
extern void DTRRFS(char *uplo, char *trans, char *diag, int *n, int *nrhs, double *a, int *lda, double *b, int *ldb, double *x, int *ldx, double *ferr, double *berr, double *work, int *iwork, int *info, int uplo_len, int trans_len, int diag_len);
extern void DTRSEN(char *job, char *compq, int *select, int *n, double *t, int *ldt, double *q, int *ldq, double *wr, double *wi, int *m, double *s, double *sep, double *work, int *lwork, int *iwork, int *liwork, int *info, int job_len, int compq_len);
extern void DTRSNA(char *job, char *howmny, int *select, int *n, double *t, int *ldt, double *vl, int *ldvl, double *vr, int *ldvr, double *s, double *sep, int *mm, int *m, double *work, int *ldwork, int *iwork, int *info, int job_len, int howmny_len);
extern void DTRSYL(char *trana, char *tranb, int *isgn, int *m, int *n, double *a, int *lda, double *b, int *ldb, double *c, int *ldc, double *scale, int *info, int trana_len, int tranb_len);
extern void DTRTRI(char *uplo, char *diag, int *n, double *a, int *lda, int *info, int uplo_len, int diag_len);
extern void DTRTRS(char *uplo, char *trans, char *diag, int *n, int *nrhs, double *a, int *lda, double *b, int *ldb, int *info, int uplo_len, int trans_len, int diag_len);
extern void DTZRQF(int *m, int *n, double *a, int *lda, double *tau, int *info);
extern void DTZRZF(int *m, int *n, double *a, int *lda, double *tau, double *work, int *lwork, int *info);
extern void SBDSDC(char *uplo, char *compq, int *n, float *d, float *e, float *u, int *ldu, float *vt, int *ldvt, float *q, int *iq, float *work, int *iwork, int *info, int uplo_len, int compq_len);
extern void SBDSQR(char *uplo, int *n, int *ncvt, int *nru, int *ncc, float *d, float *e, float *vt, int *ldvt, float *u, int *ldu, float *c, int *ldc, float *work, int *info, int uplo_len);
extern void SDISNA(char *job, int *m, int *n, float *d, float *sep, int *info, int job_len);

#ifdef FORTRAN_FLOAT_FUNCTIONS_RETURN_DOUBLE
extern double SECOND(void);
#else
extern float SECOND(void);
#endif

extern void SGBBRD(char *vect, int *m, int *n, int *ncc, int *kl, int *ku, float *ab, int *ldab, float *d, float *e, float *q, int *ldq, float *pt, int *ldpt, float *c, int *ldc, float *work, int *info, int vect_len);
extern void SGBCON(char *norm, int *n, int *kl, int *ku, float *ab, int *ldab, int *ipiv, float *anorm, float *rcond, float *work, int *iwork, int *info, int norm_len);
extern void SGBEQU(int *m, int *n, int *kl, int *ku, float *ab, int *ldab, float *r, float *c, float *rowcnd, float *colcnd, float *amax, int *info);
extern void SGBRFS(char *trans, int *n, int *kl, int *ku, int *nrhs, float *ab, int *ldab, float *afb, int *ldafb, int *ipiv, float *b, int *ldb, float *x, int *ldx, float *ferr, float *berr, float *work, int *iwork, int *info, int trans_len);
extern void SGBSV(int *n, int *kl, int *ku, int *nrhs, float *ab, int *ldab, int *ipiv, float *b, int *ldb, int *info);
extern void SGBSVX(char *fact, char *trans, int *n, int *kl, int *ku, int *nrhs, float *ab, int *ldab, float *afb, int *ldafb, int *ipiv, char *equed, float *r, float *c, float *b, int *ldb, float *x, int *ldx, float *rcond, float *ferr, float *berr, float *work, int *iwork, int *info, int fact_len, int trans_len, int equed_len);
extern void SGBTRF(int *m, int *n, int *kl, int *ku, float *ab, int *ldab, int *ipiv, int *info);
extern void SGBTRS(char *trans, int *n, int *kl, int *ku, int *nrhs, float *ab, int *ldab, int *ipiv, float *b, int *ldb, int *info, int trans_len);
extern void SGEBAK(char *job, char *side, int *n, int *ilo, int *ihi, float *scale, int *m, float *v, int *ldv, int *info, int job_len, int side_len);
extern void SGEBAL(char *job, int *n, float *a, int *lda, int *ilo, int *ihi, float *scale, int *info, int job_len);
extern void SGEBRD(int *m, int *n, float *a, int *lda, float *d, float *e, float *tauq, float *taup, float *work, int *lwork, int *info);
extern void SGECON(char *norm, int *n, float *a, int *lda, float *anorm, float *rcond, float *work, int *iwork, int *info, int norm_len);
extern void SGEEQU(int *m, int *n, float *a, int *lda, float *r, float *c, float *rowcnd, float *colcnd, float *amax, int *info);
extern void SGEES(char *jobvs, char *sort, ACML_SGEES_SELECT select, int *n, float *a, int *lda, int *sdim, float *wr, float *wi, float *vs, int *ldvs, float *work, int *lwork, int *bwork, int *info, int jobvs_len, int sort_len);
extern void SGEESX(char *jobvs, char *sort, ACML_SGEESX_SELECT select, char *sense, int *n, float *a, int *lda, int *sdim, float *wr, float *wi, float *vs, int *ldvs, float *rconde, float *rcondv, float *work, int *lwork, int *iwork, int *liwork, int *bwork, int *info, int jobvs_len, int sort_len, int sense_len);
extern void SGEEV(char *jobvl, char *jobvr, int *n, float *a, int *lda, float *wr, float *wi, float *vl, int *ldvl, float *vr, int *ldvr, float *work, int *lwork, int *info, int jobvl_len, int jobvr_len);
extern void SGEEVX(char *balanc, char *jobvl, char *jobvr, char *sense, int *n, float *a, int *lda, float *wr, float *wi, float *vl, int *ldvl, float *vr, int *ldvr, int *ilo, int *ihi, float *scale, float *abnrm, float *rconde, float *rcondv, float *work, int *lwork, int *iwork, int *info, int balanc_len, int jobvl_len, int jobvr_len, int sense_len);
extern void SGEGS(char *jobvsl, char *jobvsr, int *n, float *a, int *lda, float *b, int *ldb, float *alphar, float *alphai, float *beta, float *vsl, int *ldvsl, float *vsr, int *ldvsr, float *work, int *lwork, int *info, int jobvsl_len, int jobvsr_len);
extern void SGEGV(char *jobvl, char *jobvr, int *n, float *a, int *lda, float *b, int *ldb, float *alphar, float *alphai, float *beta, float *vl, int *ldvl, float *vr, int *ldvr, float *work, int *lwork, int *info, int jobvl_len, int jobvr_len);
extern void SGEHRD(int *n, int *ilo, int *ihi, float *a, int *lda, float *tau, float *work, int *lwork, int *info);
extern void SGELQF(int *m, int *n, float *a, int *lda, float *tau, float *work, int *lwork, int *info);
extern void SGELS(char *trans, int *m, int *n, int *nrhs, float *a, int *lda, float *b, int *ldb, float *work, int *lwork, int *info, int trans_len);
extern void SGELSD(int *m, int *n, int *nrhs, float *a, int *lda, float *b, int *ldb, float *s, float *rcond, int *rank, float *work, int *lwork, int *iwork, int *info);
extern void SGELSS(int *m, int *n, int *nrhs, float *a, int *lda, float *b, int *ldb, float *s, float *rcond, int *rank, float *work, int *lwork, int *info);
extern void SGELSX(int *m, int *n, int *nrhs, float *a, int *lda, float *b, int *ldb, int *jpvt, float *rcond, int *rank, float *work, int *info);
extern void SGELSY(int *m, int *n, int *nrhs, float *a, int *lda, float *b, int *ldb, int *jpvt, float *rcond, int *rank, float *work, int *lwork, int *info);
extern void SGEQLF(int *m, int *n, float *a, int *lda, float *tau, float *work, int *lwork, int *info);
extern void SGEQP3(int *m, int *n, float *a, int *lda, int *jpvt, float *tau, float *work, int *lwork, int *info);
extern void SGEQPF(int *m, int *n, float *a, int *lda, int *jpvt, float *tau, float *work, int *info);
extern void SGEQRF(int *m, int *n, float *a, int *lda, float *tau, float *work, int *lwork, int *info);
extern void SGERFS(char *trans, int *n, int *nrhs, float *a, int *lda, float *af, int *ldaf, int *ipiv, float *b, int *ldb, float *x, int *ldx, float *ferr, float *berr, float *work, int *iwork, int *info, int trans_len);
extern void SGERQF(int *m, int *n, float *a, int *lda, float *tau, float *work, int *lwork, int *info);
extern void SGESDD(char *jobz, int *m, int *n, float *a, int *lda, float *s, float *u, int *ldu, float *vt, int *ldvt, float *work, int *lwork, int *iwork, int *info, int jobz_len);
extern void SGESV(int *n, int *nrhs, float *a, int *lda, int *ipiv, float *b, int *ldb, int *info);
extern void SGESVD(char *jobu, char *jobvt, int *m, int *n, float *a, int *lda, float *s, float *u, int *ldu, float *vt, int *ldvt, float *work, int *lwork, int *info, int jobu_len, int jobvt_len);
extern void SGESVX(char *fact, char *trans, int *n, int *nrhs, float *a, int *lda, float *af, int *ldaf, int *ipiv, char *equed, float *r, float *c, float *b, int *ldb, float *x, int *ldx, float *rcond, float *ferr, float *berr, float *work, int *iwork, int *info, int fact_len, int trans_len, int equed_len);
extern void SGETRF(int *m, int *n, float *a, int *lda, int *ipiv, int *info);
extern void SGETRI(int *n, float *a, int *lda, int *ipiv, float *work, int *lwork, int *info);
extern void SGETRS(char *trans, int *n, int *nrhs, float *a, int *lda, int *ipiv, float *b, int *ldb, int *info, int trans_len);
extern void SGGBAK(char *job, char *side, int *n, int *ilo, int *ihi, float *lscale, float *rscale, int *m, float *v, int *ldv, int *info, int job_len, int side_len);
extern void SGGBAL(char *job, int *n, float *a, int *lda, float *b, int *ldb, int *ilo, int *ihi, float *lscale, float *rscale, float *work, int *info, int job_len);
extern void SGGES(char *jobvsl, char *jobvsr, char *sort, ACML_SGGES_SELCTG selctg, int *n, float *a, int *lda, float *b, int *ldb, int *sdim, float *alphar, float *alphai, float *beta, float *vsl, int *ldvsl, float *vsr, int *ldvsr, float *work, int *lwork, int *bwork, int *info, int jobvsl_len, int jobvsr_len, int sort_len);
extern void SGGESX(char *jobvsl, char *jobvsr, char *sort, ACML_SGGESX_SELCTG selctg, char *sense, int *n, float *a, int *lda, float *b, int *ldb, int *sdim, float *alphar, float *alphai, float *beta, float *vsl, int *ldvsl, float *vsr, int *ldvsr, float *rconde, float *rcondv, float *work, int *lwork, int *iwork, int *liwork, int *bwork, int *info, int jobvsl_len, int jobvsr_len, int sort_len, int sense_len);
extern void SGGEV(char *jobvl, char *jobvr, int *n, float *a, int *lda, float *b, int *ldb, float *alphar, float *alphai, float *beta, float *vl, int *ldvl, float *vr, int *ldvr, float *work, int *lwork, int *info, int jobvl_len, int jobvr_len);
extern void SGGEVX(char *balanc, char *jobvl, char *jobvr, char *sense, int *n, float *a, int *lda, float *b, int *ldb, float *alphar, float *alphai, float *beta, float *vl, int *ldvl, float *vr, int *ldvr, int *ilo, int *ihi, float *lscale, float *rscale, float *abnrm, float *bbnrm, float *rconde, float *rcondv, float *work, int *lwork, int *iwork, int *bwork, int *info, int balanc_len, int jobvl_len, int jobvr_len, int sense_len);
extern void SGGGLM(int *n, int *m, int *p, float *a, int *lda, float *b, int *ldb, float *d, float *x, float *y, float *work, int *lwork, int *info);
extern void SGGHRD(char *compq, char *compz, int *n, int *ilo, int *ihi, float *a, int *lda, float *b, int *ldb, float *q, int *ldq, float *z, int *ldz, int *info, int compq_len, int compz_len);
extern void SGGLSE(int *m, int *n, int *p, float *a, int *lda, float *b, int *ldb, float *c, float *d, float *x, float *work, int *lwork, int *info);
extern void SGGQRF(int *n, int *m, int *p, float *a, int *lda, float *taua, float *b, int *ldb, float *taub, float *work, int *lwork, int *info);
extern void SGGRQF(int *m, int *p, int *n, float *a, int *lda, float *taua, float *b, int *ldb, float *taub, float *work, int *lwork, int *info);
extern void SGGSVD(char *jobu, char *jobv, char *jobq, int *m, int *n, int *p, int *k, int *l, float *a, int *lda, float *b, int *ldb, float *alpha, float *beta, float *u, int *ldu, float *v, int *ldv, float *q, int *ldq, float *work, int *iwork, int *info, int jobu_len, int jobv_len, int jobq_len);
extern void SGGSVP(char *jobu, char *jobv, char *jobq, int *m, int *p, int *n, float *a, int *lda, float *b, int *ldb, float *tola, float *tolb, int *k, int *l, float *u, int *ldu, float *v, int *ldv, float *q, int *ldq, int *iwork, float *tau, float *work, int *info, int jobu_len, int jobv_len, int jobq_len);
extern void SGTCON(char *norm, int *n, float *dl, float *d, float *du, float *du2, int *ipiv, float *anorm, float *rcond, float *work, int *iwork, int *info, int norm_len);
extern void SGTRFS(char *trans, int *n, int *nrhs, float *dl, float *d, float *du, float *dlf, float *df, float *duf, float *du2, int *ipiv, float *b, int *ldb, float *x, int *ldx, float *ferr, float *berr, float *work, int *iwork, int *info, int trans_len);
extern void SGTSV(int *n, int *nrhs, float *dl, float *d, float *du, float *b, int *ldb, int *info);
extern void SGTSVX(char *fact, char *trans, int *n, int *nrhs, float *dl, float *d, float *du, float *dlf, float *df, float *duf, float *du2, int *ipiv, float *b, int *ldb, float *x, int *ldx, float *rcond, float *ferr, float *berr, float *work, int *iwork, int *info, int fact_len, int trans_len);
extern void SGTTRF(int *n, float *dl, float *d, float *du, float *du2, int *ipiv, int *info);
extern void SGTTRS(char *trans, int *n, int *nrhs, float *dl, float *d, float *du, float *du2, int *ipiv, float *b, int *ldb, int *info, int trans_len);
extern void SHGEQZ(char *job, char *compq, char *compz, int *n, int *ilo, int *ihi, float *a, int *lda, float *b, int *ldb, float *alphar, float *alphai, float *beta, float *q, int *ldq, float *z, int *ldz, float *work, int *lwork, int *info, int job_len, int compq_len, int compz_len);
extern void SHSEIN(char *side, char *eigsrc, char *initv, int *select, int *n, float *h, int *ldh, float *wr, float *wi, float *vl, int *ldvl, float *vr, int *ldvr, int *mm, int *m, float *work, int *ifaill, int *ifailr, int *info, int side_len, int eigsrc_len, int initv_len);
extern void SHSEQR(char *job, char *compz, int *n, int *ilo, int *ihi, float *h, int *ldh, float *wr, float *wi, float *z, int *ldz, float *work, int *lwork, int *info, int job_len, int compz_len);
extern int SISNAN(float *sin);

#ifdef FORTRAN_FLOAT_FUNCTIONS_RETURN_DOUBLE
extern double SLAMCH(char *cmach, int cmach_len);
#else
extern float SLAMCH(char *cmach, int cmach_len);
#endif

extern void SLASRT(char *id, int *n, float *d, int *info, int id_len);
extern void SLASSQ(int *n, float *x, int *incx, float *scale, float *sumsq);
extern void SOPGTR(char *uplo, int *n, float *ap, float *tau, float *q, int *ldq, float *work, int *info, int uplo_len);
extern void SOPMTR(char *side, char *uplo, char *trans, int *m, int *n, float *ap, float *tau, float *c, int *ldc, float *work, int *info, int side_len, int uplo_len, int trans_len);
extern void SORGBR(char *vect, int *m, int *n, int *k, float *a, int *lda, float *tau, float *work, int *lwork, int *info, int vect_len);
extern void SORGHR(int *n, int *ilo, int *ihi, float *a, int *lda, float *tau, float *work, int *lwork, int *info);
extern void SORGLQ(int *m, int *n, int *k, float *a, int *lda, float *tau, float *work, int *lwork, int *info);
extern void SORGQL(int *m, int *n, int *k, float *a, int *lda, float *tau, float *work, int *lwork, int *info);
extern void SORGQR(int *m, int *n, int *k, float *a, int *lda, float *tau, float *work, int *lwork, int *info);
extern void SORGRQ(int *m, int *n, int *k, float *a, int *lda, float *tau, float *work, int *lwork, int *info);
extern void SORGTR(char *uplo, int *n, float *a, int *lda, float *tau, float *work, int *lwork, int *info, int uplo_len);
extern void SORMBR(char *vect, char *side, char *trans, int *m, int *n, int *k, float *a, int *lda, float *tau, float *c, int *ldc, float *work, int *lwork, int *info, int vect_len, int side_len, int trans_len);
extern void SORMHR(char *side, char *trans, int *m, int *n, int *ilo, int *ihi, float *a, int *lda, float *tau, float *c, int *ldc, float *work, int *lwork, int *info, int side_len, int trans_len);
extern void SORMLQ(char *side, char *trans, int *m, int *n, int *k, float *a, int *lda, float *tau, float *c, int *ldc, float *work, int *lwork, int *info, int side_len, int trans_len);
extern void SORMQL(char *side, char *trans, int *m, int *n, int *k, float *a, int *lda, float *tau, float *c, int *ldc, float *work, int *lwork, int *info, int side_len, int trans_len);
extern void SORMQR(char *side, char *trans, int *m, int *n, int *k, float *a, int *lda, float *tau, float *c, int *ldc, float *work, int *lwork, int *info, int side_len, int trans_len);
extern void SORMR3(char *side, char *trans, int *m, int *n, int *k, int *l, float *a, int *lda, float *tau, float *c, int *ldc, float *work, int *info, int side_len, int trans_len);
extern void SORMRQ(char *side, char *trans, int *m, int *n, int *k, float *a, int *lda, float *tau, float *c, int *ldc, float *work, int *lwork, int *info, int side_len, int trans_len);
extern void SORMRZ(char *side, char *trans, int *m, int *n, int *k, int *l, float *a, int *lda, float *tau, float *c, int *ldc, float *work, int *lwork, int *info, int side_len, int trans_len);
extern void SORMTR(char *side, char *uplo, char *trans, int *m, int *n, float *a, int *lda, float *tau, float *c, int *ldc, float *work, int *lwork, int *info, int side_len, int uplo_len, int trans_len);
extern void SPBCON(char *uplo, int *n, int *kd, float *ab, int *ldab, float *anorm, float *rcond, float *work, int *iwork, int *info, int uplo_len);
extern void SPBEQU(char *uplo, int *n, int *kd, float *ab, int *ldab, float *s, float *scond, float *amax, int *info, int uplo_len);
extern void SPBRFS(char *uplo, int *n, int *kd, int *nrhs, float *ab, int *ldab, float *afb, int *ldafb, float *b, int *ldb, float *x, int *ldx, float *ferr, float *berr, float *work, int *iwork, int *info, int uplo_len);
extern void SPBSTF(char *uplo, int *n, int *kd, float *ab, int *ldab, int *info, int uplo_len);
extern void SPBSV(char *uplo, int *n, int *kd, int *nrhs, float *ab, int *ldab, float *b, int *ldb, int *info, int uplo_len);
extern void SPBSVX(char *fact, char *uplo, int *n, int *kd, int *nrhs, float *ab, int *ldab, float *afb, int *ldafb, char *equed, float *s, float *b, int *ldb, float *x, int *ldx, float *rcond, float *ferr, float *berr, float *work, int *iwork, int *info, int fact_len, int uplo_len, int equed_len);
extern void SPBTRF(char *uplo, int *n, int *kd, float *ab, int *ldab, int *info, int uplo_len);
extern void SPBTRS(char *uplo, int *n, int *kd, int *nrhs, float *ab, int *ldab, float *b, int *ldb, int *info, int uplo_len);
extern void SPOCON(char *uplo, int *n, float *a, int *lda, float *anorm, float *rcond, float *work, int *iwork, int *info, int uplo_len);
extern void SPOEQU(int *n, float *a, int *lda, float *s, float *scond, float *amax, int *info);
extern void SPORFS(char *uplo, int *n, int *nrhs, float *a, int *lda, float *af, int *ldaf, float *b, int *ldb, float *x, int *ldx, float *ferr, float *berr, float *work, int *iwork, int *info, int uplo_len);
extern void SPOSV(char *uplo, int *n, int *nrhs, float *a, int *lda, float *b, int *ldb, int *info, int uplo_len);
extern void SPOSVX(char *fact, char *uplo, int *n, int *nrhs, float *a, int *lda, float *af, int *ldaf, char *equed, float *s, float *b, int *ldb, float *x, int *ldx, float *rcond, float *ferr, float *berr, float *work, int *iwork, int *info, int fact_len, int uplo_len, int equed_len);
extern void SPOTRF(char *uplo, int *n, float *a, int *lda, int *info, int uplo_len);
extern void SPOTRI(char *uplo, int *n, float *a, int *lda, int *info, int uplo_len);
extern void SPOTRS(char *uplo, int *n, int *nrhs, float *a, int *lda, float *b, int *ldb, int *info, int uplo_len);
extern void SPPCON(char *uplo, int *n, float *ap, float *anorm, float *rcond, float *work, int *iwork, int *info, int uplo_len);
extern void SPPEQU(char *uplo, int *n, float *ap, float *s, float *scond, float *amax, int *info, int uplo_len);
extern void SPPRFS(char *uplo, int *n, int *nrhs, float *ap, float *afp, float *b, int *ldb, float *x, int *ldx, float *ferr, float *berr, float *work, int *iwork, int *info, int uplo_len);
extern void SPPSV(char *uplo, int *n, int *nrhs, float *ap, float *b, int *ldb, int *info, int uplo_len);
extern void SPPSVX(char *fact, char *uplo, int *n, int *nrhs, float *ap, float *afp, char *equed, float *s, float *b, int *ldb, float *x, int *ldx, float *rcond, float *ferr, float *berr, float *work, int *iwork, int *info, int fact_len, int uplo_len, int equed_len);
extern void SPPTRF(char *uplo, int *n, float *ap, int *info, int uplo_len);
extern void SPPTRI(char *uplo, int *n, float *ap, int *info, int uplo_len);
extern void SPPTRS(char *uplo, int *n, int *nrhs, float *ap, float *b, int *ldb, int *info, int uplo_len);
extern void SPTCON(int *n, float *d, float *e, float *anorm, float *rcond, float *work, int *info);
extern void SPTEQR(char *compz, int *n, float *d, float *e, float *z, int *ldz, float *work, int *info, int compz_len);
extern void SPTRFS(int *n, int *nrhs, float *d, float *e, float *df, float *ef, float *b, int *ldb, float *x, int *ldx, float *ferr, float *berr, float *work, int *info);
extern void SPTSV(int *n, int *nrhs, float *d, float *e, float *b, int *ldb, int *info);
extern void SPTSVX(char *fact, int *n, int *nrhs, float *d, float *e, float *df, float *ef, float *b, int *ldb, float *x, int *ldx, float *rcond, float *ferr, float *berr, float *work, int *info, int fact_len);
extern void SPTTRF(int *n, float *d, float *e, int *info);
extern void SPTTRS(int *n, int *nrhs, float *d, float *e, float *b, int *ldb, int *info);
extern void SSBEV(char *jobz, char *uplo, int *n, int *kd, float *ab, int *ldab, float *w, float *z, int *ldz, float *work, int *info, int jobz_len, int uplo_len);
extern void SSBEVD(char *jobz, char *uplo, int *n, int *kd, float *ab, int *ldab, float *w, float *z, int *ldz, float *work, int *lwork, int *iwork, int *liwork, int *info, int jobz_len, int uplo_len);
extern void SSBEVX(char *jobz, char *range, char *uplo, int *n, int *kd, float *ab, int *ldab, float *q, int *ldq, float *vl, float *vu, int *il, int *iu, float *abstol, int *m, float *w, float *z, int *ldz, float *work, int *iwork, int *ifail, int *info, int jobz_len, int range_len, int uplo_len);
extern void SSBGST(char *vect, char *uplo, int *n, int *ka, int *kb, float *ab, int *ldab, float *bb, int *ldbb, float *x, int *ldx, float *work, int *info, int vect_len, int uplo_len);
extern void SSBGV(char *jobz, char *uplo, int *n, int *ka, int *kb, float *ab, int *ldab, float *bb, int *ldbb, float *w, float *z, int *ldz, float *work, int *info, int jobz_len, int uplo_len);
extern void SSBGVD(char *jobz, char *uplo, int *n, int *ka, int *kb, float *ab, int *ldab, float *bb, int *ldbb, float *w, float *z, int *ldz, float *work, int *lwork, int *iwork, int *liwork, int *info, int jobz_len, int uplo_len);
extern void SSBGVX(char *jobz, char *range, char *uplo, int *n, int *ka, int *kb, float *ab, int *ldab, float *bb, int *ldbb, float *q, int *ldq, float *vl, float *vu, int *il, int *iu, float *abstol, int *m, float *w, float *z, int *ldz, float *work, int *iwork, int *ifail, int *info, int jobz_len, int range_len, int uplo_len);
extern void SSBTRD(char *vect, char *uplo, int *n, int *kd, float *ab, int *ldab, float *d, float *e, float *q, int *ldq, float *work, int *info, int vect_len, int uplo_len);
extern void SSPCON(char *uplo, int *n, float *ap, int *ipiv, float *anorm, float *rcond, float *work, int *iwork, int *info, int uplo_len);
extern void SSPEV(char *jobz, char *uplo, int *n, float *ap, float *w, float *z, int *ldz, float *work, int *info, int jobz_len, int uplo_len);
extern void SSPEVD(char *jobz, char *uplo, int *n, float *ap, float *w, float *z, int *ldz, float *work, int *lwork, int *iwork, int *liwork, int *info, int jobz_len, int uplo_len);
extern void SSPEVX(char *jobz, char *range, char *uplo, int *n, float *ap, float *vl, float *vu, int *il, int *iu, float *abstol, int *m, float *w, float *z, int *ldz, float *work, int *iwork, int *ifail, int *info, int jobz_len, int range_len, int uplo_len);
extern void SSPGST(int *itype, char *uplo, int *n, float *ap, float *bp, int *info, int uplo_len);
extern void SSPGV(int *itype, char *jobz, char *uplo, int *n, float *ap, float *bp, float *w, float *z, int *ldz, float *work, int *info, int jobz_len, int uplo_len);
extern void SSPGVD(int *itype, char *jobz, char *uplo, int *n, float *ap, float *bp, float *w, float *z, int *ldz, float *work, int *lwork, int *iwork, int *liwork, int *info, int jobz_len, int uplo_len);
extern void SSPGVX(int *itype, char *jobz, char *range, char *uplo, int *n, float *ap, float *bp, float *vl, float *vu, int *il, int *iu, float *abstol, int *m, float *w, float *z, int *ldz, float *work, int *iwork, int *ifail, int *info, int jobz_len, int range_len, int uplo_len);
extern void SSPRFS(char *uplo, int *n, int *nrhs, float *ap, float *afp, int *ipiv, float *b, int *ldb, float *x, int *ldx, float *ferr, float *berr, float *work, int *iwork, int *info, int uplo_len);
extern void SSPSV(char *uplo, int *n, int *nrhs, float *ap, int *ipiv, float *b, int *ldb, int *info, int uplo_len);
extern void SSPSVX(char *fact, char *uplo, int *n, int *nrhs, float *ap, float *afp, int *ipiv, float *b, int *ldb, float *x, int *ldx, float *rcond, float *ferr, float *berr, float *work, int *iwork, int *info, int fact_len, int uplo_len);
extern void SSPTRD(char *uplo, int *n, float *ap, float *d, float *e, float *tau, int *info, int uplo_len);
extern void SSPTRF(char *uplo, int *n, float *ap, int *ipiv, int *info, int uplo_len);
extern void SSPTRI(char *uplo, int *n, float *ap, int *ipiv, float *work, int *info, int uplo_len);
extern void SSPTRS(char *uplo, int *n, int *nrhs, float *ap, int *ipiv, float *b, int *ldb, int *info, int uplo_len);
extern void SSTEBZ(char *range, char *order, int *n, float *vl, float *vu, int *il, int *iu, float *abstol, float *d, float *e, int *m, int *nsplit, float *w, int *iblock, int *isplit, float *work, int *iwork, int *info, int range_len, int order_len);
extern void SSTEDC(char *compz, int *n, float *d, float *e, float *z, int *ldz, float *work, int *lwork, int *iwork, int *liwork, int *info, int compz_len);
extern void SSTEGR(char *jobz, char *range, int *n, float *d, float *e, float *vl, float *vu, int *il, int *iu, float *abstol, int *m, float *w, float *z, int *ldz, int *isuppz, float *work, int *lwork, int *iwork, int *liwork, int *info, int jobz_len, int range_len);
extern void SSTEIN(int *n, float *d, float *e, int *m, float *w, int *iblock, int *isplit, float *z, int *ldz, float *work, int *iwork, int *ifail, int *info);
extern void SSTEQR(char *compz, int *n, float *d, float *e, float *z, int *ldz, float *work, int *info, int compz_len);
extern void SSTERF(int *n, float *d, float *e, int *info);
extern void SSTEV(char *jobz, int *n, float *d, float *e, float *z, int *ldz, float *work, int *info, int jobz_len);
extern void SSTEVD(char *jobz, int *n, float *d, float *e, float *z, int *ldz, float *work, int *lwork, int *iwork, int *liwork, int *info, int jobz_len);
extern void SSTEVR(char *jobz, char *range, int *n, float *d, float *e, float *vl, float *vu, int *il, int *iu, float *abstol, int *m, float *w, float *z, int *ldz, int *isuppz, float *work, int *lwork, int *iwork, int *liwork, int *info, int jobz_len, int range_len);
extern void SSTEVX(char *jobz, char *range, int *n, float *d, float *e, float *vl, float *vu, int *il, int *iu, float *abstol, int *m, float *w, float *z, int *ldz, float *work, int *iwork, int *ifail, int *info, int jobz_len, int range_len);
extern void SSYCON(char *uplo, int *n, float *a, int *lda, int *ipiv, float *anorm, float *rcond, float *work, int *iwork, int *info, int uplo_len);
extern void SSYEV(char *jobz, char *uplo, int *n, float *a, int *lda, float *w, float *work, int *lwork, int *info, int jobz_len, int uplo_len);
extern void SSYEVD(char *jobz, char *uplo, int *n, float *a, int *lda, float *w, float *work, int *lwork, int *iwork, int *liwork, int *info, int jobz_len, int uplo_len);
extern void SSYEVR(char *jobz, char *range, char *uplo, int *n, float *a, int *lda, float *vl, float *vu, int *il, int *iu, float *abstol, int *m, float *w, float *z, int *ldz, int *isuppz, float *work, int *lwork, int *iwork, int *liwork, int *info, int jobz_len, int range_len, int uplo_len);
extern void SSYEVX(char *jobz, char *range, char *uplo, int *n, float *a, int *lda, float *vl, float *vu, int *il, int *iu, float *abstol, int *m, float *w, float *z, int *ldz, float *work, int *lwork, int *iwork, int *ifail, int *info, int jobz_len, int range_len, int uplo_len);
extern void SSYGST(int *itype, char *uplo, int *n, float *a, int *lda, float *b, int *ldb, int *info, int uplo_len);
extern void SSYGV(int *itype, char *jobz, char *uplo, int *n, float *a, int *lda, float *b, int *ldb, float *w, float *work, int *lwork, int *info, int jobz_len, int uplo_len);
extern void SSYGVD(int *itype, char *jobz, char *uplo, int *n, float *a, int *lda, float *b, int *ldb, float *w, float *work, int *lwork, int *iwork, int *liwork, int *info, int jobz_len, int uplo_len);
extern void SSYGVX(int *itype, char *jobz, char *range, char *uplo, int *n, float *a, int *lda, float *b, int *ldb, float *vl, float *vu, int *il, int *iu, float *abstol, int *m, float *w, float *z, int *ldz, float *work, int *lwork, int *iwork, int *ifail, int *info, int jobz_len, int range_len, int uplo_len);
extern void SSYRFS(char *uplo, int *n, int *nrhs, float *a, int *lda, float *af, int *ldaf, int *ipiv, float *b, int *ldb, float *x, int *ldx, float *ferr, float *berr, float *work, int *iwork, int *info, int uplo_len);
extern void SSYSV(char *uplo, int *n, int *nrhs, float *a, int *lda, int *ipiv, float *b, int *ldb, float *work, int *lwork, int *info, int uplo_len);
extern void SSYSVX(char *fact, char *uplo, int *n, int *nrhs, float *a, int *lda, float *af, int *ldaf, int *ipiv, float *b, int *ldb, float *x, int *ldx, float *rcond, float *ferr, float *berr, float *work, int *lwork, int *iwork, int *info, int fact_len, int uplo_len);
extern void SSYTRD(char *uplo, int *n, float *a, int *lda, float *d, float *e, float *tau, float *work, int *lwork, int *info, int uplo_len);
extern void SSYTRF(char *uplo, int *n, float *a, int *lda, int *ipiv, float *work, int *lwork, int *info, int uplo_len);
extern void SSYTRI(char *uplo, int *n, float *a, int *lda, int *ipiv, float *work, int *info, int uplo_len);
extern void SSYTRS(char *uplo, int *n, int *nrhs, float *a, int *lda, int *ipiv, float *b, int *ldb, int *info, int uplo_len);
extern void STBCON(char *norm, char *uplo, char *diag, int *n, int *kd, float *ab, int *ldab, float *rcond, float *work, int *iwork, int *info, int norm_len, int uplo_len, int diag_len);
extern void STBRFS(char *uplo, char *trans, char *diag, int *n, int *kd, int *nrhs, float *ab, int *ldab, float *b, int *ldb, float *x, int *ldx, float *ferr, float *berr, float *work, int *iwork, int *info, int uplo_len, int trans_len, int diag_len);
extern void STBTRS(char *uplo, char *trans, char *diag, int *n, int *kd, int *nrhs, float *ab, int *ldab, float *b, int *ldb, int *info, int uplo_len, int trans_len, int diag_len);
extern void STGEVC(char *side, char *howmny, int *select, int *n, float *a, int *lda, float *b, int *ldb, float *vl, int *ldvl, float *vr, int *ldvr, int *mm, int *m, float *work, int *info, int side_len, int howmny_len);
extern void STGEXC(int *wantq, int *wantz, int *n, float *a, int *lda, float *b, int *ldb, float *q, int *ldq, float *z, int *ldz, int *ifst, int *ilst, float *work, int *lwork, int *info);
extern void STGSEN(int *ijob, int *wantq, int *wantz, int *select, int *n, float *a, int *lda, float *b, int *ldb, float *alphar, float *alphai, float *beta, float *q, int *ldq, float *z, int *ldz, int *m, float *pl, float *pr, float *dif, float *work, int *lwork, int *iwork, int *liwork, int *info);
extern void STGSJA(char *jobu, char *jobv, char *jobq, int *m, int *p, int *n, int *k, int *l, float *a, int *lda, float *b, int *ldb, float *tola, float *tolb, float *alpha, float *beta, float *u, int *ldu, float *v, int *ldv, float *q, int *ldq, float *work, int *ncycle, int *info, int jobu_len, int jobv_len, int jobq_len);
extern void STGSNA(char *job, char *howmny, int *select, int *n, float *a, int *lda, float *b, int *ldb, float *vl, int *ldvl, float *vr, int *ldvr, float *s, float *dif, int *mm, int *m, float *work, int *lwork, int *iwork, int *info, int job_len, int howmny_len);
extern void STGSYL(char *trans, int *ijob, int *m, int *n, float *a, int *lda, float *b, int *ldb, float *c, int *ldc, float *d, int *ldd, float *e, int *lde, float *f, int *ldf, float *scale, float *dif, float *work, int *lwork, int *iwork, int *info, int trans_len);
extern void STPCON(char *norm, char *uplo, char *diag, int *n, float *ap, float *rcond, float *work, int *iwork, int *info, int norm_len, int uplo_len, int diag_len);
extern void STPRFS(char *uplo, char *trans, char *diag, int *n, int *nrhs, float *ap, float *b, int *ldb, float *x, int *ldx, float *ferr, float *berr, float *work, int *iwork, int *info, int uplo_len, int trans_len, int diag_len);
extern void STPTRI(char *uplo, char *diag, int *n, float *ap, int *info, int uplo_len, int diag_len);
extern void STPTRS(char *uplo, char *trans, char *diag, int *n, int *nrhs, float *ap, float *b, int *ldb, int *info, int uplo_len, int trans_len, int diag_len);
extern void STRCON(char *norm, char *uplo, char *diag, int *n, float *a, int *lda, float *rcond, float *work, int *iwork, int *info, int norm_len, int uplo_len, int diag_len);
extern void STREVC(char *side, char *howmny, int *select, int *n, float *t, int *ldt, float *vl, int *ldvl, float *vr, int *ldvr, int *mm, int *m, float *work, int *info, int side_len, int howmny_len);
extern void STREXC(char *compq, int *n, float *t, int *ldt, float *q, int *ldq, int *ifst, int *ilst, float *work, int *info, int compq_len);
extern void STRRFS(char *uplo, char *trans, char *diag, int *n, int *nrhs, float *a, int *lda, float *b, int *ldb, float *x, int *ldx, float *ferr, float *berr, float *work, int *iwork, int *info, int uplo_len, int trans_len, int diag_len);
extern void STRSEN(char *job, char *compq, int *select, int *n, float *t, int *ldt, float *q, int *ldq, float *wr, float *wi, int *m, float *s, float *sep, float *work, int *lwork, int *iwork, int *liwork, int *info, int job_len, int compq_len);
extern void STRSNA(char *job, char *howmny, int *select, int *n, float *t, int *ldt, float *vl, int *ldvl, float *vr, int *ldvr, float *s, float *sep, int *mm, int *m, float *work, int *ldwork, int *iwork, int *info, int job_len, int howmny_len);
extern void STRSYL(char *trana, char *tranb, int *isgn, int *m, int *n, float *a, int *lda, float *b, int *ldb, float *c, int *ldc, float *scale, int *info, int trana_len, int tranb_len);
extern void STRTRI(char *uplo, char *diag, int *n, float *a, int *lda, int *info, int uplo_len, int diag_len);
extern void STRTRS(char *uplo, char *trans, char *diag, int *n, int *nrhs, float *a, int *lda, float *b, int *ldb, int *info, int uplo_len, int trans_len, int diag_len);
extern void STZRQF(int *m, int *n, float *a, int *lda, float *tau, int *info);
extern void STZRZF(int *m, int *n, float *a, int *lda, float *tau, float *work, int *lwork, int *info);
extern void ZBDSQR(char *uplo, int *n, int *ncvt, int *nru, int *ncc, double *d, double *e, doublecomplex *vt, int *ldvt, doublecomplex *u, int *ldu, doublecomplex *c, int *ldc, double *rwork, int *info, int uplo_len);
extern void ZCGESV(int *n, int *nrhs, doublecomplex *a, int *lda, int *ipiv, doublecomplex *b, int *ldb, doublecomplex *x, int *ldx, doublecomplex *work, complex *swork, int *iter, int *info);
extern void ZGBBRD(char *vect, int *m, int *n, int *ncc, int *kl, int *ku, doublecomplex *ab, int *ldab, double *d, double *e, doublecomplex *q, int *ldq, doublecomplex *pt, int *ldpt, doublecomplex *c, int *ldc, doublecomplex *work, double *rwork, int *info, int vect_len);
extern void ZGBCON(char *norm, int *n, int *kl, int *ku, doublecomplex *ab, int *ldab, int *ipiv, double *anorm, double *rcond, doublecomplex *work, double *rwork, int *info, int norm_len);
extern void ZGBEQU(int *m, int *n, int *kl, int *ku, doublecomplex *ab, int *ldab, double *r, double *c, double *rowcnd, double *colcnd, double *amax, int *info);
extern void ZGBRFS(char *trans, int *n, int *kl, int *ku, int *nrhs, doublecomplex *ab, int *ldab, doublecomplex *afb, int *ldafb, int *ipiv, doublecomplex *b, int *ldb, doublecomplex *x, int *ldx, double *ferr, double *berr, doublecomplex *work, double *rwork, int *info, int trans_len);
extern void ZGBSV(int *n, int *kl, int *ku, int *nrhs, doublecomplex *ab, int *ldab, int *ipiv, doublecomplex *b, int *ldb, int *info);
extern void ZGBSVX(char *fact, char *trans, int *n, int *kl, int *ku, int *nrhs, doublecomplex *ab, int *ldab, doublecomplex *afb, int *ldafb, int *ipiv, char *equed, double *r, double *c, doublecomplex *b, int *ldb, doublecomplex *x, int *ldx, double *rcond, double *ferr, double *berr, doublecomplex *work, double *rwork, int *info, int fact_len, int trans_len, int equed_len);
extern void ZGBTRF(int *m, int *n, int *kl, int *ku, doublecomplex *ab, int *ldab, int *ipiv, int *info);
extern void ZGBTRS(char *trans, int *n, int *kl, int *ku, int *nrhs, doublecomplex *ab, int *ldab, int *ipiv, doublecomplex *b, int *ldb, int *info, int trans_len);
extern void ZGEBAK(char *job, char *side, int *n, int *ilo, int *ihi, double *scale, int *m, doublecomplex *v, int *ldv, int *info, int job_len, int side_len);
extern void ZGEBAL(char *job, int *n, doublecomplex *a, int *lda, int *ilo, int *ihi, double *scale, int *info, int job_len);
extern void ZGEBRD(int *m, int *n, doublecomplex *a, int *lda, double *d, double *e, doublecomplex *tauq, doublecomplex *taup, doublecomplex *work, int *lwork, int *info);
extern void ZGECON(char *norm, int *n, doublecomplex *a, int *lda, double *anorm, double *rcond, doublecomplex *work, double *rwork, int *info, int norm_len);
extern void ZGEEQU(int *m, int *n, doublecomplex *a, int *lda, double *r, double *c, double *rowcnd, double *colcnd, double *amax, int *info);
extern void ZGEES(char *jobvs, char *sort, ACML_ZGEES_SELECT select, int *n, doublecomplex *a, int *lda, int *sdim, doublecomplex *w, doublecomplex *vs, int *ldvs, doublecomplex *work, int *lwork, double *rwork, int *bwork, int *info, int jobvs_len, int sort_len);
extern void ZGEESX(char *jobvs, char *sort, ACML_ZGEESX_SELECT select, char *sense, int *n, doublecomplex *a, int *lda, int *sdim, doublecomplex *w, doublecomplex *vs, int *ldvs, double *rconde, double *rcondv, doublecomplex *work, int *lwork, double *rwork, int *bwork, int *info, int jobvs_len, int sort_len, int sense_len);
extern void ZGEEV(char *jobvl, char *jobvr, int *n, doublecomplex *a, int *lda, doublecomplex *w, doublecomplex *vl, int *ldvl, doublecomplex *vr, int *ldvr, doublecomplex *work, int *lwork, double *rwork, int *info, int jobvl_len, int jobvr_len);
extern void ZGEEVX(char *balanc, char *jobvl, char *jobvr, char *sense, int *n, doublecomplex *a, int *lda, doublecomplex *w, doublecomplex *vl, int *ldvl, doublecomplex *vr, int *ldvr, int *ilo, int *ihi, double *scale, double *abnrm, double *rconde, double *rcondv, doublecomplex *work, int *lwork, double *rwork, int *info, int balanc_len, int jobvl_len, int jobvr_len, int sense_len);
extern void ZGEGS(char *jobvsl, char *jobvsr, int *n, doublecomplex *a, int *lda, doublecomplex *b, int *ldb, doublecomplex *alpha, doublecomplex *beta, doublecomplex *vsl, int *ldvsl, doublecomplex *vsr, int *ldvsr, doublecomplex *work, int *lwork, double *rwork, int *info, int jobvsl_len, int jobvsr_len);
extern void ZGEGV(char *jobvl, char *jobvr, int *n, doublecomplex *a, int *lda, doublecomplex *b, int *ldb, doublecomplex *alpha, doublecomplex *beta, doublecomplex *vl, int *ldvl, doublecomplex *vr, int *ldvr, doublecomplex *work, int *lwork, double *rwork, int *info, int jobvl_len, int jobvr_len);
extern void ZGEHRD(int *n, int *ilo, int *ihi, doublecomplex *a, int *lda, doublecomplex *tau, doublecomplex *work, int *lwork, int *info);
extern void ZGELQF(int *m, int *n, doublecomplex *a, int *lda, doublecomplex *tau, doublecomplex *work, int *lwork, int *info);
extern void ZGELS(char *trans, int *m, int *n, int *nrhs, doublecomplex *a, int *lda, doublecomplex *b, int *ldb, doublecomplex *work, int *lwork, int *info, int trans_len);
extern void ZGELSD(int *m, int *n, int *nrhs, doublecomplex *a, int *lda, doublecomplex *b, int *ldb, double *s, double *rcond, int *rank, doublecomplex *work, int *lwork, double *rwork, int *iwork, int *info);
extern void ZGELSS(int *m, int *n, int *nrhs, doublecomplex *a, int *lda, doublecomplex *b, int *ldb, double *s, double *rcond, int *rank, doublecomplex *work, int *lwork, double *rwork, int *info);
extern void ZGELSX(int *m, int *n, int *nrhs, doublecomplex *a, int *lda, doublecomplex *b, int *ldb, int *jpvt, double *rcond, int *rank, doublecomplex *work, double *rwork, int *info);
extern void ZGELSY(int *m, int *n, int *nrhs, doublecomplex *a, int *lda, doublecomplex *b, int *ldb, int *jpvt, double *rcond, int *rank, doublecomplex *work, int *lwork, double *rwork, int *info);
extern void ZGEQLF(int *m, int *n, doublecomplex *a, int *lda, doublecomplex *tau, doublecomplex *work, int *lwork, int *info);
extern void ZGEQP3(int *m, int *n, doublecomplex *a, int *lda, int *jpvt, doublecomplex *tau, doublecomplex *work, int *lwork, double *rwork, int *info);
extern void ZGEQPF(int *m, int *n, doublecomplex *a, int *lda, int *jpvt, doublecomplex *tau, doublecomplex *work, double *rwork, int *info);
extern void ZGEQRF(int *m, int *n, doublecomplex *a, int *lda, doublecomplex *tau, doublecomplex *work, int *lwork, int *info);
extern void ZGERFS(char *trans, int *n, int *nrhs, doublecomplex *a, int *lda, doublecomplex *af, int *ldaf, int *ipiv, doublecomplex *b, int *ldb, doublecomplex *x, int *ldx, double *ferr, double *berr, doublecomplex *work, double *rwork, int *info, int trans_len);
extern void ZGERQF(int *m, int *n, doublecomplex *a, int *lda, doublecomplex *tau, doublecomplex *work, int *lwork, int *info);
extern void ZGESDD(char *jobz, int *m, int *n, doublecomplex *a, int *lda, double *s, doublecomplex *u, int *ldu, doublecomplex *vt, int *ldvt, doublecomplex *work, int *lwork, double *rwork, int *iwork, int *info, int jobz_len);
extern void ZGESV(int *n, int *nrhs, doublecomplex *a, int *lda, int *ipiv, doublecomplex *b, int *ldb, int *info);
extern void ZGESVD(char *jobu, char *jobvt, int *m, int *n, doublecomplex *a, int *lda, double *s, doublecomplex *u, int *ldu, doublecomplex *vt, int *ldvt, doublecomplex *work, int *lwork, double *rwork, int *info, int jobu_len, int jobvt_len);
extern void ZGESVX(char *fact, char *trans, int *n, int *nrhs, doublecomplex *a, int *lda, doublecomplex *af, int *ldaf, int *ipiv, char *equed, double *r, double *c, doublecomplex *b, int *ldb, doublecomplex *x, int *ldx, double *rcond, double *ferr, double *berr, doublecomplex *work, double *rwork, int *info, int fact_len, int trans_len, int equed_len);
extern void ZGETRF(int *m, int *n, doublecomplex *a, int *lda, int *ipiv, int *info);
extern void ZGETRI(int *n, doublecomplex *a, int *lda, int *ipiv, doublecomplex *work, int *lwork, int *info);
extern void ZGETRS(char *trans, int *n, int *nrhs, doublecomplex *a, int *lda, int *ipiv, doublecomplex *b, int *ldb, int *info, int trans_len);
extern void ZGGBAK(char *job, char *side, int *n, int *ilo, int *ihi, double *lscale, double *rscale, int *m, doublecomplex *v, int *ldv, int *info, int job_len, int side_len);
extern void ZGGBAL(char *job, int *n, doublecomplex *a, int *lda, doublecomplex *b, int *ldb, int *ilo, int *ihi, double *lscale, double *rscale, double *work, int *info, int job_len);
extern void ZGGES(char *jobvsl, char *jobvsr, char *sort, ACML_ZGGES_DELCTG delctg, int *n, doublecomplex *a, int *lda, doublecomplex *b, int *ldb, int *sdim, doublecomplex *alpha, doublecomplex *beta, doublecomplex *vsl, int *ldvsl, doublecomplex *vsr, int *ldvsr, doublecomplex *work, int *lwork, double *rwork, int *bwork, int *info, int jobvsl_len, int jobvsr_len, int sort_len);
extern void ZGGESX(char *jobvsl, char *jobvsr, char *sort, ACML_ZGGESX_DELCTG delctg, char *sense, int *n, doublecomplex *a, int *lda, doublecomplex *b, int *ldb, int *sdim, doublecomplex *alpha, doublecomplex *beta, doublecomplex *vsl, int *ldvsl, doublecomplex *vsr, int *ldvsr, double *rconde, double *rcondv, doublecomplex *work, int *lwork, double *rwork, int *iwork, int *liwork, int *bwork, int *info, int jobvsl_len, int jobvsr_len, int sort_len, int sense_len);
extern void ZGGEV(char *jobvl, char *jobvr, int *n, doublecomplex *a, int *lda, doublecomplex *b, int *ldb, doublecomplex *alpha, doublecomplex *beta, doublecomplex *vl, int *ldvl, doublecomplex *vr, int *ldvr, doublecomplex *work, int *lwork, double *rwork, int *info, int jobvl_len, int jobvr_len);
extern void ZGGEVX(char *balanc, char *jobvl, char *jobvr, char *sense, int *n, doublecomplex *a, int *lda, doublecomplex *b, int *ldb, doublecomplex *alpha, doublecomplex *beta, doublecomplex *vl, int *ldvl, doublecomplex *vr, int *ldvr, int *ilo, int *ihi, double *lscale, double *rscale, double *abnrm, double *bbnrm, double *rconde, double *rcondv, doublecomplex *work, int *lwork, double *rwork, int *iwork, int *bwork, int *info, int balanc_len, int jobvl_len, int jobvr_len, int sense_len);
extern void ZGGGLM(int *n, int *m, int *p, doublecomplex *a, int *lda, doublecomplex *b, int *ldb, doublecomplex *d, doublecomplex *x, doublecomplex *y, doublecomplex *work, int *lwork, int *info);
extern void ZGGHRD(char *compq, char *compz, int *n, int *ilo, int *ihi, doublecomplex *a, int *lda, doublecomplex *b, int *ldb, doublecomplex *q, int *ldq, doublecomplex *z, int *ldz, int *info, int compq_len, int compz_len);
extern void ZGGLSE(int *m, int *n, int *p, doublecomplex *a, int *lda, doublecomplex *b, int *ldb, doublecomplex *c, doublecomplex *d, doublecomplex *x, doublecomplex *work, int *lwork, int *info);
extern void ZGGQRF(int *n, int *m, int *p, doublecomplex *a, int *lda, doublecomplex *taua, doublecomplex *b, int *ldb, doublecomplex *taub, doublecomplex *work, int *lwork, int *info);
extern void ZGGRQF(int *m, int *p, int *n, doublecomplex *a, int *lda, doublecomplex *taua, doublecomplex *b, int *ldb, doublecomplex *taub, doublecomplex *work, int *lwork, int *info);
extern void ZGGSVD(char *jobu, char *jobv, char *jobq, int *m, int *n, int *p, int *k, int *l, doublecomplex *a, int *lda, doublecomplex *b, int *ldb, double *alpha, double *beta, doublecomplex *u, int *ldu, doublecomplex *v, int *ldv, doublecomplex *q, int *ldq, doublecomplex *work, double *rwork, int *iwork, int *info, int jobu_len, int jobv_len, int jobq_len);
extern void ZGGSVP(char *jobu, char *jobv, char *jobq, int *m, int *p, int *n, doublecomplex *a, int *lda, doublecomplex *b, int *ldb, double *tola, double *tolb, int *k, int *l, doublecomplex *u, int *ldu, doublecomplex *v, int *ldv, doublecomplex *q, int *ldq, int *iwork, double *rwork, doublecomplex *tau, doublecomplex *work, int *info, int jobu_len, int jobv_len, int jobq_len);
extern void ZGTCON(char *norm, int *n, doublecomplex *dl, doublecomplex *d, doublecomplex *du, doublecomplex *du2, int *ipiv, double *anorm, double *rcond, doublecomplex *work, int *info, int norm_len);
extern void ZGTRFS(char *trans, int *n, int *nrhs, doublecomplex *dl, doublecomplex *d, doublecomplex *du, doublecomplex *dlf, doublecomplex *df, doublecomplex *duf, doublecomplex *du2, int *ipiv, doublecomplex *b, int *ldb, doublecomplex *x, int *ldx, double *ferr, double *berr, doublecomplex *work, double *rwork, int *info, int trans_len);
extern void ZGTSV(int *n, int *nrhs, doublecomplex *dl, doublecomplex *d, doublecomplex *du, doublecomplex *b, int *ldb, int *info);
extern void ZGTSVX(char *fact, char *trans, int *n, int *nrhs, doublecomplex *dl, doublecomplex *d, doublecomplex *du, doublecomplex *dlf, doublecomplex *df, doublecomplex *duf, doublecomplex *du2, int *ipiv, doublecomplex *b, int *ldb, doublecomplex *x, int *ldx, double *rcond, double *ferr, double *berr, doublecomplex *work, double *rwork, int *info, int fact_len, int trans_len);
extern void ZGTTRF(int *n, doublecomplex *dl, doublecomplex *d, doublecomplex *du, doublecomplex *du2, int *ipiv, int *info);
extern void ZGTTRS(char *trans, int *n, int *nrhs, doublecomplex *dl, doublecomplex *d, doublecomplex *du, doublecomplex *du2, int *ipiv, doublecomplex *b, int *ldb, int *info, int trans_len);
extern void ZHBEV(char *jobz, char *uplo, int *n, int *kd, doublecomplex *ab, int *ldab, double *w, doublecomplex *z, int *ldz, doublecomplex *work, double *rwork, int *info, int jobz_len, int uplo_len);
extern void ZHBEVD(char *jobz, char *uplo, int *n, int *kd, doublecomplex *ab, int *ldab, double *w, doublecomplex *z, int *ldz, doublecomplex *work, int *lwork, double *rwork, int *lrwork, int *iwork, int *liwork, int *info, int jobz_len, int uplo_len);
extern void ZHBEVX(char *jobz, char *range, char *uplo, int *n, int *kd, doublecomplex *ab, int *ldab, doublecomplex *q, int *ldq, double *vl, double *vu, int *il, int *iu, double *abstol, int *m, double *w, doublecomplex *z, int *ldz, doublecomplex *work, double *rwork, int *iwork, int *ifail, int *info, int jobz_len, int range_len, int uplo_len);
extern void ZHBGST(char *vect, char *uplo, int *n, int *ka, int *kb, doublecomplex *ab, int *ldab, doublecomplex *bb, int *ldbb, doublecomplex *x, int *ldx, doublecomplex *work, double *rwork, int *info, int vect_len, int uplo_len);
extern void ZHBGV(char *jobz, char *uplo, int *n, int *ka, int *kb, doublecomplex *ab, int *ldab, doublecomplex *bb, int *ldbb, double *w, doublecomplex *z, int *ldz, doublecomplex *work, double *rwork, int *info, int jobz_len, int uplo_len);
extern void ZHBGVD(char *jobz, char *uplo, int *n, int *ka, int *kb, doublecomplex *ab, int *ldab, doublecomplex *bb, int *ldbb, double *w, doublecomplex *z, int *ldz, doublecomplex *work, int *lwork, double *rwork, int *lrwork, int *iwork, int *liwork, int *info, int jobz_len, int uplo_len);
extern void ZHBGVX(char *jobz, char *range, char *uplo, int *n, int *ka, int *kb, doublecomplex *ab, int *ldab, doublecomplex *bb, int *ldbb, doublecomplex *q, int *ldq, double *vl, double *vu, int *il, int *iu, double *abstol, int *m, double *w, doublecomplex *z, int *ldz, doublecomplex *work, double *rwork, int *iwork, int *ifail, int *info, int jobz_len, int range_len, int uplo_len);
extern void ZHBTRD(char *vect, char *uplo, int *n, int *kd, doublecomplex *ab, int *ldab, double *d, double *e, doublecomplex *q, int *ldq, doublecomplex *work, int *info, int vect_len, int uplo_len);
extern void ZHECON(char *uplo, int *n, doublecomplex *a, int *lda, int *ipiv, double *anorm, double *rcond, doublecomplex *work, int *info, int uplo_len);
extern void ZHEEV(char *jobz, char *uplo, int *n, doublecomplex *a, int *lda, double *w, doublecomplex *work, int *lwork, double *rwork, int *info, int jobz_len, int uplo_len);
extern void ZHEEVD(char *jobz, char *uplo, int *n, doublecomplex *a, int *lda, double *w, doublecomplex *work, int *lwork, double *rwork, int *lrwork, int *iwork, int *liwork, int *info, int jobz_len, int uplo_len);
extern void ZHEEVR(char *jobz, char *range, char *uplo, int *n, doublecomplex *a, int *lda, double *vl, double *vu, int *il, int *iu, double *abstol, int *m, double *w, doublecomplex *z, int *ldz, int *isuppz, doublecomplex *work, int *lwork, double *rwork, int *lrwork, int *iwork, int *liwork, int *info, int jobz_len, int range_len, int uplo_len);
extern void ZHEEVX(char *jobz, char *range, char *uplo, int *n, doublecomplex *a, int *lda, double *vl, double *vu, int *il, int *iu, double *abstol, int *m, double *w, doublecomplex *z, int *ldz, doublecomplex *work, int *lwork, double *rwork, int *iwork, int *ifail, int *info, int jobz_len, int range_len, int uplo_len);
extern void ZHEGST(int *itype, char *uplo, int *n, doublecomplex *a, int *lda, doublecomplex *b, int *ldb, int *info, int uplo_len);
extern void ZHEGV(int *itype, char *jobz, char *uplo, int *n, doublecomplex *a, int *lda, doublecomplex *b, int *ldb, double *w, doublecomplex *work, int *lwork, double *rwork, int *info, int jobz_len, int uplo_len);
extern void ZHEGVD(int *itype, char *jobz, char *uplo, int *n, doublecomplex *a, int *lda, doublecomplex *b, int *ldb, double *w, doublecomplex *work, int *lwork, double *rwork, int *lrwork, int *iwork, int *liwork, int *info, int jobz_len, int uplo_len);
extern void ZHEGVX(int *itype, char *jobz, char *range, char *uplo, int *n, doublecomplex *a, int *lda, doublecomplex *b, int *ldb, double *vl, double *vu, int *il, int *iu, double *abstol, int *m, double *w, doublecomplex *z, int *ldz, doublecomplex *work, int *lwork, double *rwork, int *iwork, int *ifail, int *info, int jobz_len, int range_len, int uplo_len);
extern void ZHERFS(char *uplo, int *n, int *nrhs, doublecomplex *a, int *lda, doublecomplex *af, int *ldaf, int *ipiv, doublecomplex *b, int *ldb, doublecomplex *x, int *ldx, double *ferr, double *berr, doublecomplex *work, double *rwork, int *info, int uplo_len);
extern void ZHESV(char *uplo, int *n, int *nrhs, doublecomplex *a, int *lda, int *ipiv, doublecomplex *b, int *ldb, doublecomplex *work, int *lwork, int *info, int uplo_len);
extern void ZHESVX(char *fact, char *uplo, int *n, int *nrhs, doublecomplex *a, int *lda, doublecomplex *af, int *ldaf, int *ipiv, doublecomplex *b, int *ldb, doublecomplex *x, int *ldx, double *rcond, double *ferr, double *berr, doublecomplex *work, int *lwork, double *rwork, int *info, int fact_len, int uplo_len);
extern void ZHETRD(char *uplo, int *n, doublecomplex *a, int *lda, double *d, double *e, doublecomplex *tau, doublecomplex *work, int *lwork, int *info, int uplo_len);
extern void ZHETRF(char *uplo, int *n, doublecomplex *a, int *lda, int *ipiv, doublecomplex *work, int *lwork, int *info, int uplo_len);
extern void ZHETRI(char *uplo, int *n, doublecomplex *a, int *lda, int *ipiv, doublecomplex *work, int *info, int uplo_len);
extern void ZHETRS(char *uplo, int *n, int *nrhs, doublecomplex *a, int *lda, int *ipiv, doublecomplex *b, int *ldb, int *info, int uplo_len);
extern void ZHGEQZ(char *job, char *compq, char *compz, int *n, int *ilo, int *ihi, doublecomplex *a, int *lda, doublecomplex *b, int *ldb, doublecomplex *alpha, doublecomplex *beta, doublecomplex *q, int *ldq, doublecomplex *z, int *ldz, doublecomplex *work, int *lwork, double *rwork, int *info, int job_len, int compq_len, int compz_len);
extern void ZHPCON(char *uplo, int *n, doublecomplex *ap, int *ipiv, double *anorm, double *rcond, doublecomplex *work, int *info, int uplo_len);
extern void ZHPEV(char *jobz, char *uplo, int *n, doublecomplex *ap, double *w, doublecomplex *z, int *ldz, doublecomplex *work, double *rwork, int *info, int jobz_len, int uplo_len);
extern void ZHPEVD(char *jobz, char *uplo, int *n, doublecomplex *ap, double *w, doublecomplex *z, int *ldz, doublecomplex *work, int *lwork, double *rwork, int *lrwork, int *iwork, int *liwork, int *info, int jobz_len, int uplo_len);
extern void ZHPEVX(char *jobz, char *range, char *uplo, int *n, doublecomplex *ap, double *vl, double *vu, int *il, int *iu, double *abstol, int *m, double *w, doublecomplex *z, int *ldz, doublecomplex *work, double *rwork, int *iwork, int *ifail, int *info, int jobz_len, int range_len, int uplo_len);
extern void ZHPGST(int *itype, char *uplo, int *n, doublecomplex *ap, doublecomplex *bp, int *info, int uplo_len);
extern void ZHPGV(int *itype, char *jobz, char *uplo, int *n, doublecomplex *ap, doublecomplex *bp, double *w, doublecomplex *z, int *ldz, doublecomplex *work, double *rwork, int *info, int jobz_len, int uplo_len);
extern void ZHPGVD(int *itype, char *jobz, char *uplo, int *n, doublecomplex *ap, doublecomplex *bp, double *w, doublecomplex *z, int *ldz, doublecomplex *work, int *lwork, double *rwork, int *lrwork, int *iwork, int *liwork, int *info, int jobz_len, int uplo_len);
extern void ZHPGVX(int *itype, char *jobz, char *range, char *uplo, int *n, doublecomplex *ap, doublecomplex *bp, double *vl, double *vu, int *il, int *iu, double *abstol, int *m, double *w, doublecomplex *z, int *ldz, doublecomplex *work, double *rwork, int *iwork, int *ifail, int *info, int jobz_len, int range_len, int uplo_len);
extern void ZHPRFS(char *uplo, int *n, int *nrhs, doublecomplex *ap, doublecomplex *afp, int *ipiv, doublecomplex *b, int *ldb, doublecomplex *x, int *ldx, double *ferr, double *berr, doublecomplex *work, double *rwork, int *info, int uplo_len);
extern void ZHPSV(char *uplo, int *n, int *nrhs, doublecomplex *ap, int *ipiv, doublecomplex *b, int *ldb, int *info, int uplo_len);
extern void ZHPSVX(char *fact, char *uplo, int *n, int *nrhs, doublecomplex *ap, doublecomplex *afp, int *ipiv, doublecomplex *b, int *ldb, doublecomplex *x, int *ldx, double *rcond, double *ferr, double *berr, doublecomplex *work, double *rwork, int *info, int fact_len, int uplo_len);
extern void ZHPTRD(char *uplo, int *n, doublecomplex *ap, double *d, double *e, doublecomplex *tau, int *info, int uplo_len);
extern void ZHPTRF(char *uplo, int *n, doublecomplex *ap, int *ipiv, int *info, int uplo_len);
extern void ZHPTRI(char *uplo, int *n, doublecomplex *ap, int *ipiv, doublecomplex *work, int *info, int uplo_len);
extern void ZHPTRS(char *uplo, int *n, int *nrhs, doublecomplex *ap, int *ipiv, doublecomplex *b, int *ldb, int *info, int uplo_len);
extern void ZHSEIN(char *side, char *eigsrc, char *initv, int *select, int *n, doublecomplex *h, int *ldh, doublecomplex *w, doublecomplex *vl, int *ldvl, doublecomplex *vr, int *ldvr, int *mm, int *m, doublecomplex *work, double *rwork, int *ifaill, int *ifailr, int *info, int side_len, int eigsrc_len, int initv_len);
extern void ZHSEQR(char *job, char *compz, int *n, int *ilo, int *ihi, doublecomplex *h, int *ldh, doublecomplex *w, doublecomplex *z, int *ldz, doublecomplex *work, int *lwork, int *info, int job_len, int compz_len);
extern void ZPBCON(char *uplo, int *n, int *kd, doublecomplex *ab, int *ldab, double *anorm, double *rcond, doublecomplex *work, double *rwork, int *info, int uplo_len);
extern void ZPBEQU(char *uplo, int *n, int *kd, doublecomplex *ab, int *ldab, double *s, double *scond, double *amax, int *info, int uplo_len);
extern void ZPBRFS(char *uplo, int *n, int *kd, int *nrhs, doublecomplex *ab, int *ldab, doublecomplex *afb, int *ldafb, doublecomplex *b, int *ldb, doublecomplex *x, int *ldx, double *ferr, double *berr, doublecomplex *work, double *rwork, int *info, int uplo_len);
extern void ZPBSTF(char *uplo, int *n, int *kd, doublecomplex *ab, int *ldab, int *info, int uplo_len);
extern void ZPBSV(char *uplo, int *n, int *kd, int *nrhs, doublecomplex *ab, int *ldab, doublecomplex *b, int *ldb, int *info, int uplo_len);
extern void ZPBSVX(char *fact, char *uplo, int *n, int *kd, int *nrhs, doublecomplex *ab, int *ldab, doublecomplex *afb, int *ldafb, char *equed, double *s, doublecomplex *b, int *ldb, doublecomplex *x, int *ldx, double *rcond, double *ferr, double *berr, doublecomplex *work, double *rwork, int *info, int fact_len, int uplo_len, int equed_len);
extern void ZPBTRF(char *uplo, int *n, int *kd, doublecomplex *ab, int *ldab, int *info, int uplo_len);
extern void ZPBTRS(char *uplo, int *n, int *kd, int *nrhs, doublecomplex *ab, int *ldab, doublecomplex *b, int *ldb, int *info, int uplo_len);
extern void ZPOCON(char *uplo, int *n, doublecomplex *a, int *lda, double *anorm, double *rcond, doublecomplex *work, double *rwork, int *info, int uplo_len);
extern void ZPOEQU(int *n, doublecomplex *a, int *lda, double *s, double *scond, double *amax, int *info);
extern void ZPORFS(char *uplo, int *n, int *nrhs, doublecomplex *a, int *lda, doublecomplex *af, int *ldaf, doublecomplex *b, int *ldb, doublecomplex *x, int *ldx, double *ferr, double *berr, doublecomplex *work, double *rwork, int *info, int uplo_len);
extern void ZPOSV(char *uplo, int *n, int *nrhs, doublecomplex *a, int *lda, doublecomplex *b, int *ldb, int *info, int uplo_len);
extern void ZPOSVX(char *fact, char *uplo, int *n, int *nrhs, doublecomplex *a, int *lda, doublecomplex *af, int *ldaf, char *equed, double *s, doublecomplex *b, int *ldb, doublecomplex *x, int *ldx, double *rcond, double *ferr, double *berr, doublecomplex *work, double *rwork, int *info, int fact_len, int uplo_len, int equed_len);
extern void ZPOTRF(char *uplo, int *n, doublecomplex *a, int *lda, int *info, int uplo_len);
extern void ZPOTRI(char *uplo, int *n, doublecomplex *a, int *lda, int *info, int uplo_len);
extern void ZPOTRS(char *uplo, int *n, int *nrhs, doublecomplex *a, int *lda, doublecomplex *b, int *ldb, int *info, int uplo_len);
extern void ZPPCON(char *uplo, int *n, doublecomplex *ap, double *anorm, double *rcond, doublecomplex *work, double *rwork, int *info, int uplo_len);
extern void ZPPEQU(char *uplo, int *n, doublecomplex *ap, double *s, double *scond, double *amax, int *info, int uplo_len);
extern void ZPPRFS(char *uplo, int *n, int *nrhs, doublecomplex *ap, doublecomplex *afp, doublecomplex *b, int *ldb, doublecomplex *x, int *ldx, double *ferr, double *berr, doublecomplex *work, double *rwork, int *info, int uplo_len);
extern void ZPPSV(char *uplo, int *n, int *nrhs, doublecomplex *ap, doublecomplex *b, int *ldb, int *info, int uplo_len);
extern void ZPPSVX(char *fact, char *uplo, int *n, int *nrhs, doublecomplex *ap, doublecomplex *afp, char *equed, double *s, doublecomplex *b, int *ldb, doublecomplex *x, int *ldx, double *rcond, double *ferr, double *berr, doublecomplex *work, double *rwork, int *info, int fact_len, int uplo_len, int equed_len);
extern void ZPPTRF(char *uplo, int *n, doublecomplex *ap, int *info, int uplo_len);
extern void ZPPTRI(char *uplo, int *n, doublecomplex *ap, int *info, int uplo_len);
extern void ZPPTRS(char *uplo, int *n, int *nrhs, doublecomplex *ap, doublecomplex *b, int *ldb, int *info, int uplo_len);
extern void ZPTCON(int *n, double *d, doublecomplex *e, double *anorm, double *rcond, double *rwork, int *info);
extern void ZPTEQR(char *compz, int *n, double *d, double *e, doublecomplex *z, int *ldz, double *work, int *info, int compz_len);
extern void ZPTRFS(char *uplo, int *n, int *nrhs, double *d, doublecomplex *e, double *df, doublecomplex *ef, doublecomplex *b, int *ldb, doublecomplex *x, int *ldx, double *ferr, double *berr, doublecomplex *work, double *rwork, int *info, int uplo_len);
extern void ZPTSV(int *n, int *nrhs, double *d, doublecomplex *e, doublecomplex *b, int *ldb, int *info);
extern void ZPTSVX(char *fact, int *n, int *nrhs, double *d, doublecomplex *e, double *df, doublecomplex *ef, doublecomplex *b, int *ldb, doublecomplex *x, int *ldx, double *rcond, double *ferr, double *berr, doublecomplex *work, double *rwork, int *info, int fact_len);
extern void ZPTTRF(int *n, double *d, doublecomplex *e, int *info);
extern void ZPTTRS(char *uplo, int *n, int *nrhs, double *d, doublecomplex *e, doublecomplex *b, int *ldb, int *info, int uplo_len);
extern void ZSPCON(char *uplo, int *n, doublecomplex *ap, int *ipiv, double *anorm, double *rcond, doublecomplex *work, int *info, int uplo_len);
extern void ZSPRFS(char *uplo, int *n, int *nrhs, doublecomplex *ap, doublecomplex *afp, int *ipiv, doublecomplex *b, int *ldb, doublecomplex *x, int *ldx, double *ferr, double *berr, doublecomplex *work, double *rwork, int *info, int uplo_len);
extern void ZSPSV(char *uplo, int *n, int *nrhs, doublecomplex *ap, int *ipiv, doublecomplex *b, int *ldb, int *info, int uplo_len);
extern void ZSPSVX(char *fact, char *uplo, int *n, int *nrhs, doublecomplex *ap, doublecomplex *afp, int *ipiv, doublecomplex *b, int *ldb, doublecomplex *x, int *ldx, double *rcond, double *ferr, double *berr, doublecomplex *work, double *rwork, int *info, int fact_len, int uplo_len);
extern void ZSPTRF(char *uplo, int *n, doublecomplex *ap, int *ipiv, int *info, int uplo_len);
extern void ZSPTRI(char *uplo, int *n, doublecomplex *ap, int *ipiv, doublecomplex *work, int *info, int uplo_len);
extern void ZSPTRS(char *uplo, int *n, int *nrhs, doublecomplex *ap, int *ipiv, doublecomplex *b, int *ldb, int *info, int uplo_len);
extern void ZSTEDC(char *compz, int *n, double *d, double *e, doublecomplex *z, int *ldz, doublecomplex *work, int *lwork, double *rwork, int *lrwork, int *iwork, int *liwork, int *info, int compz_len);
extern void ZSTEGR(char *jobz, char *range, int *n, double *d, double *e, double *vl, double *vu, int *il, int *iu, double *abstol, int *m, double *w, doublecomplex *z, int *ldz, int *isuppz, double *work, int *lwork, int *iwork, int *liwork, int *info, int jobz_len, int range_len);
extern void ZSTEIN(int *n, double *d, double *e, int *m, double *w, int *iblock, int *isplit, doublecomplex *z, int *ldz, double *work, int *iwork, int *ifail, int *info);
extern void ZSTEQR(char *compz, int *n, double *d, double *e, doublecomplex *z, int *ldz, double *work, int *info, int compz_len);
extern void ZSYCON(char *uplo, int *n, doublecomplex *a, int *lda, int *ipiv, double *anorm, double *rcond, doublecomplex *work, int *info, int uplo_len);
extern void ZSYRFS(char *uplo, int *n, int *nrhs, doublecomplex *a, int *lda, doublecomplex *af, int *ldaf, int *ipiv, doublecomplex *b, int *ldb, doublecomplex *x, int *ldx, double *ferr, double *berr, doublecomplex *work, double *rwork, int *info, int uplo_len);
extern void ZSYSV(char *uplo, int *n, int *nrhs, doublecomplex *a, int *lda, int *ipiv, doublecomplex *b, int *ldb, doublecomplex *work, int *lwork, int *info, int uplo_len);
extern void ZSYSVX(char *fact, char *uplo, int *n, int *nrhs, doublecomplex *a, int *lda, doublecomplex *af, int *ldaf, int *ipiv, doublecomplex *b, int *ldb, doublecomplex *x, int *ldx, double *rcond, double *ferr, double *berr, doublecomplex *work, int *lwork, double *rwork, int *info, int fact_len, int uplo_len);
extern void ZSYTRF(char *uplo, int *n, doublecomplex *a, int *lda, int *ipiv, doublecomplex *work, int *lwork, int *info, int uplo_len);
extern void ZSYTRI(char *uplo, int *n, doublecomplex *a, int *lda, int *ipiv, doublecomplex *work, int *info, int uplo_len);
extern void ZSYTRS(char *uplo, int *n, int *nrhs, doublecomplex *a, int *lda, int *ipiv, doublecomplex *b, int *ldb, int *info, int uplo_len);
extern void ZTBCON(char *norm, char *uplo, char *diag, int *n, int *kd, doublecomplex *ab, int *ldab, double *rcond, doublecomplex *work, double *rwork, int *info, int norm_len, int uplo_len, int diag_len);
extern void ZTBRFS(char *uplo, char *trans, char *diag, int *n, int *kd, int *nrhs, doublecomplex *ab, int *ldab, doublecomplex *b, int *ldb, doublecomplex *x, int *ldx, double *ferr, double *berr, doublecomplex *work, double *rwork, int *info, int uplo_len, int trans_len, int diag_len);
extern void ZTBTRS(char *uplo, char *trans, char *diag, int *n, int *kd, int *nrhs, doublecomplex *ab, int *ldab, doublecomplex *b, int *ldb, int *info, int uplo_len, int trans_len, int diag_len);
extern void ZTGEVC(char *side, char *howmny, int *select, int *n, doublecomplex *a, int *lda, doublecomplex *b, int *ldb, doublecomplex *vl, int *ldvl, doublecomplex *vr, int *ldvr, int *mm, int *m, doublecomplex *work, double *rwork, int *info, int side_len, int howmny_len);
extern void ZTGEXC(int *wantq, int *wantz, int *n, doublecomplex *a, int *lda, doublecomplex *b, int *ldb, doublecomplex *q, int *ldq, doublecomplex *z, int *ldz, int *ifst, int *ilst, int *info);
extern void ZTGSEN(int *ijob, int *wantq, int *wantz, int *select, int *n, doublecomplex *a, int *lda, doublecomplex *b, int *ldb, doublecomplex *alpha, doublecomplex *beta, doublecomplex *q, int *ldq, doublecomplex *z, int *ldz, int *m, double *pl, double *pr, double *dif, doublecomplex *work, int *lwork, int *iwork, int *liwork, int *info);
extern void ZTGSJA(char *jobu, char *jobv, char *jobq, int *m, int *p, int *n, int *k, int *l, doublecomplex *a, int *lda, doublecomplex *b, int *ldb, double *tola, double *tolb, double *alpha, double *beta, doublecomplex *u, int *ldu, doublecomplex *v, int *ldv, doublecomplex *q, int *ldq, doublecomplex *work, int *ncycle, int *info, int jobu_len, int jobv_len, int jobq_len);
extern void ZTGSNA(char *job, char *howmny, int *select, int *n, doublecomplex *a, int *lda, doublecomplex *b, int *ldb, doublecomplex *vl, int *ldvl, doublecomplex *vr, int *ldvr, double *s, double *dif, int *mm, int *m, doublecomplex *work, int *lwork, int *iwork, int *info, int job_len, int howmny_len);
extern void ZTGSYL(char *trans, int *ijob, int *m, int *n, doublecomplex *a, int *lda, doublecomplex *b, int *ldb, doublecomplex *c, int *ldc, doublecomplex *d, int *ldd, doublecomplex *e, int *lde, doublecomplex *f, int *ldf, double *scale, double *dif, doublecomplex *work, int *lwork, int *iwork, int *info, int trans_len);
extern void ZTPCON(char *norm, char *uplo, char *diag, int *n, doublecomplex *ap, double *rcond, doublecomplex *work, double *rwork, int *info, int norm_len, int uplo_len, int diag_len);
extern void ZTPRFS(char *uplo, char *trans, char *diag, int *n, int *nrhs, doublecomplex *ap, doublecomplex *b, int *ldb, doublecomplex *x, int *ldx, double *ferr, double *berr, doublecomplex *work, double *rwork, int *info, int uplo_len, int trans_len, int diag_len);
extern void ZTPTRI(char *uplo, char *diag, int *n, doublecomplex *ap, int *info, int uplo_len, int diag_len);
extern void ZTPTRS(char *uplo, char *trans, char *diag, int *n, int *nrhs, doublecomplex *ap, doublecomplex *b, int *ldb, int *info, int uplo_len, int trans_len, int diag_len);
extern void ZTRCON(char *norm, char *uplo, char *diag, int *n, doublecomplex *a, int *lda, double *rcond, doublecomplex *work, double *rwork, int *info, int norm_len, int uplo_len, int diag_len);
extern void ZTREVC(char *side, char *howmny, int *select, int *n, doublecomplex *t, int *ldt, doublecomplex *vl, int *ldvl, doublecomplex *vr, int *ldvr, int *mm, int *m, doublecomplex *work, double *rwork, int *info, int side_len, int howmny_len);
extern void ZTREXC(char *compq, int *n, doublecomplex *t, int *ldt, doublecomplex *q, int *ldq, int *ifst, int *ilst, int *info, int compq_len);
extern void ZTRRFS(char *uplo, char *trans, char *diag, int *n, int *nrhs, doublecomplex *a, int *lda, doublecomplex *b, int *ldb, doublecomplex *x, int *ldx, double *ferr, double *berr, doublecomplex *work, double *rwork, int *info, int uplo_len, int trans_len, int diag_len);
extern void ZTRSEN(char *job, char *compq, int *select, int *n, doublecomplex *t, int *ldt, doublecomplex *q, int *ldq, doublecomplex *w, int *m, double *s, double *sep, doublecomplex *work, int *lwork, int *info, int job_len, int compq_len);
extern void ZTRSNA(char *job, char *howmny, int *select, int *n, doublecomplex *t, int *ldt, doublecomplex *vl, int *ldvl, doublecomplex *vr, int *ldvr, double *s, double *sep, int *mm, int *m, doublecomplex *work, int *ldwork, double *rwork, int *info, int job_len, int howmny_len);
extern void ZTRSYL(char *trana, char *tranb, int *isgn, int *m, int *n, doublecomplex *a, int *lda, doublecomplex *b, int *ldb, doublecomplex *c, int *ldc, double *scale, int *info, int trana_len, int tranb_len);
extern void ZTRTRI(char *uplo, char *diag, int *n, doublecomplex *a, int *lda, int *info, int uplo_len, int diag_len);
extern void ZTRTRS(char *uplo, char *trans, char *diag, int *n, int *nrhs, doublecomplex *a, int *lda, doublecomplex *b, int *ldb, int *info, int uplo_len, int trans_len, int diag_len);
extern void ZTZRQF(int *m, int *n, doublecomplex *a, int *lda, doublecomplex *tau, int *info);
extern void ZTZRZF(int *m, int *n, doublecomplex *a, int *lda, doublecomplex *tau, doublecomplex *work, int *lwork, int *info);
extern void ZUNGBR(char *vect, int *m, int *n, int *k, doublecomplex *a, int *lda, doublecomplex *tau, doublecomplex *work, int *lwork, int *info, int vect_len);
extern void ZUNGHR(int *n, int *ilo, int *ihi, doublecomplex *a, int *lda, doublecomplex *tau, doublecomplex *work, int *lwork, int *info);
extern void ZUNGLQ(int *m, int *n, int *k, doublecomplex *a, int *lda, doublecomplex *tau, doublecomplex *work, int *lwork, int *info);
extern void ZUNGQL(int *m, int *n, int *k, doublecomplex *a, int *lda, doublecomplex *tau, doublecomplex *work, int *lwork, int *info);
extern void ZUNGQR(int *m, int *n, int *k, doublecomplex *a, int *lda, doublecomplex *tau, doublecomplex *work, int *lwork, int *info);
extern void ZUNGRQ(int *m, int *n, int *k, doublecomplex *a, int *lda, doublecomplex *tau, doublecomplex *work, int *lwork, int *info);
extern void ZUNGTR(char *uplo, int *n, doublecomplex *a, int *lda, doublecomplex *tau, doublecomplex *work, int *lwork, int *info, int uplo_len);
extern void ZUNMBR(char *vect, char *side, char *trans, int *m, int *n, int *k, doublecomplex *a, int *lda, doublecomplex *tau, doublecomplex *c, int *ldc, doublecomplex *work, int *lwork, int *info, int vect_len, int side_len, int trans_len);
extern void ZUNMHR(char *side, char *trans, int *m, int *n, int *ilo, int *ihi, doublecomplex *a, int *lda, doublecomplex *tau, doublecomplex *c, int *ldc, doublecomplex *work, int *lwork, int *info, int side_len, int trans_len);
extern void ZUNMLQ(char *side, char *trans, int *m, int *n, int *k, doublecomplex *a, int *lda, doublecomplex *tau, doublecomplex *c, int *ldc, doublecomplex *work, int *lwork, int *info, int side_len, int trans_len);
extern void ZUNMQL(char *side, char *trans, int *m, int *n, int *k, doublecomplex *a, int *lda, doublecomplex *tau, doublecomplex *c, int *ldc, doublecomplex *work, int *lwork, int *info, int side_len, int trans_len);
extern void ZUNMQR(char *side, char *trans, int *m, int *n, int *k, doublecomplex *a, int *lda, doublecomplex *tau, doublecomplex *c, int *ldc, doublecomplex *work, int *lwork, int *info, int side_len, int trans_len);
extern void ZUNMR3(char *side, char *trans, int *m, int *n, int *k, int *l, doublecomplex *a, int *lda, doublecomplex *tau, doublecomplex *c, int *ldc, doublecomplex *work, int *info, int side_len, int trans_len);
extern void ZUNMRQ(char *side, char *trans, int *m, int *n, int *k, doublecomplex *a, int *lda, doublecomplex *tau, doublecomplex *c, int *ldc, doublecomplex *work, int *lwork, int *info, int side_len, int trans_len);
extern void ZUNMRZ(char *side, char *trans, int *m, int *n, int *k, int *l, doublecomplex *a, int *lda, doublecomplex *tau, doublecomplex *c, int *ldc, doublecomplex *work, int *lwork, int *info, int side_len, int trans_len);
extern void ZUNMTR(char *side, char *uplo, char *trans, int *m, int *n, doublecomplex *a, int *lda, doublecomplex *tau, doublecomplex *c, int *ldc, doublecomplex *work, int *lwork, int *info, int side_len, int uplo_len, int trans_len);
extern void ZUPGTR(char *uplo, int *n, doublecomplex *ap, doublecomplex *tau, doublecomplex *q, int *ldq, doublecomplex *work, int *info, int uplo_len);
extern void ZUPMTR(char *side, char *uplo, char *trans, int *m, int *n, doublecomplex *ap, doublecomplex *tau, doublecomplex *c, int *ldc, doublecomplex *work, int *info, int side_len, int uplo_len, int trans_len);

/* FFT routines */
extern void CFFT1D(int *mode, int *n, complex *x, complex *comm, int *info);
extern void CFFT1DX(int *mode, float *scale, int *inpl, int *n, complex *x, int *incx, complex *y, int *incy, complex *comm, int *info);
extern void CFFT1M(int *mode, int *nseq, int *n, complex *x, complex *comm, int *info);
extern void CFFT1MX(int *mode, float *scale, int *inpl, int *nseq, int *n, complex *x, int *incx1, int *incx2, complex *y, int *incy1, int *incy2, complex *comm, int *info);
extern void CFFT2D(int *mode, int *m, int *n, complex *x, complex *comm, int *info);
extern void CFFT2DX(int *mode, float *scale, int *ltrans, int *inpl, int *m, int *n, complex *x, int *incx1, int *incx2, complex *y, int *incy1, int *incy2, complex *comm, int *info);
extern void CFFT3D(int *mode, int *l, int *m, int *n, complex *x, complex *comm, int *info);
extern void CFFT3DX(int *mode, float *scale, int *ltrans, int *inpl, int *l, int *m, int *n, complex *x, complex *y, complex *comm, int *info);
extern void CFFT3DY(int *mode, float *scale, int *inpl, int *l, int *m, int *n, complex *x, int *incx1, int *incx2, int *incx3, complex *y, int *incy1, int *incy2, int *incy3, complex *comm, int *lcomm, int *info);
extern void CSFFT(int *mode, int *n, float *x, float *comm, int *info);
extern void CSFFTM(int *nseq, int *n, float *x, float *comm, int *info);
extern void DZFFT(int *mode, int *n, double *x, double *comm, int *info);
extern void DZFFTM(int *nseq, int *n, double *x, double *comm, int *info);
extern void SCFFT(int *mode, int *n, float *x, float *comm, int *info);
extern void SCFFTM(int *nseq, int *n, float *x, float *comm, int *info);
extern void ZDFFT(int *mode, int *n, double *x, double *comm, int *info);
extern void ZDFFTM(int *nseq, int *n, double *x, double *comm, int *info);
extern void ZFFT1D(int *mode, int *n, doublecomplex *x, doublecomplex *comm, int *info);
extern void ZFFT1DX(int *mode, double *scale, int *inpl, int *n, doublecomplex *x, int *incx, doublecomplex *y, int *incy, doublecomplex *comm, int *info);
extern void ZFFT1M(int *mode, int *nseq, int *n, doublecomplex *x, doublecomplex *comm, int *info);
extern void ZFFT1MX(int *mode, double *scale, int *inpl, int *nseq, int *n, doublecomplex *x, int *incx1, int *incx2, doublecomplex *y, int *incy1, int *incy2, doublecomplex *comm, int *info);
extern void ZFFT2D(int *mode, int *m, int *n, doublecomplex *x, doublecomplex *comm, int *info);
extern void ZFFT2DX(int *mode, double *scale, int *ltrans, int *inpl, int *m, int *n, doublecomplex *x, int *incx1, int *incx2, doublecomplex *y, int *incy1, int *incy2, doublecomplex *comm, int *info);
extern void ZFFT3D(int *mode, int *l, int *m, int *n, doublecomplex *x, doublecomplex *comm, int *info);
extern void ZFFT3DX(int *mode, double *scale, int *ltrans, int *inpl, int *l, int *m, int *n, doublecomplex *x, doublecomplex *y, doublecomplex *comm, int *info);
extern void ZFFT3DY(int *mode, double *scale, int *inpl, int *l, int *m, int *n, doublecomplex *x, int *incx1, int *incx2, int *incx3, doublecomplex *y, int *incy1, int *incy2, int *incy3, doublecomplex *comm, int *lcomm, int *info);

/* Sparse BLAS routines */
extern void CAXPYI(int *nz, complex *a, complex *x, int *indx, complex *y);
extern complex CDOTCI(complex *ret_val, int *nz, complex *x, int *indx, complex *y);
extern void CDOTCISUB(complex *ret_val, int *nz, complex *x, int *indx, complex *y);
extern complex CDOTUI(complex *ret_val, int *nz, complex *x, int *indx, complex *y);
extern void CDOTUISUB(complex *ret_val, int *nz, complex *x, int *indx, complex *y);
extern void CGTHR(int *nz, complex *y, complex *x, int *indx);
extern void CGTHRZ(int *nz, complex *y, complex *x, int *indx);
extern void CSCTR(int *nz, complex *x, int *indx, complex *y);
extern void DAXPYI(int *nz, double *a, double *x, int *indx, double *y);
extern double DDOTI(int *nz, double *x, int *indx, double *y);
extern void DGTHR(int *nz, double *y, double *x, int *indx);
extern void DGTHRZ(int *nz, double *y, double *x, int *indx);
extern void DROTI(int *nz, double *x, int *indx, double *y, double *c, double *s);
extern void DSCTR(int *nz, double *x, int *indx, double *y);
extern void SAXPYI(int *nz, float *a, float *x, int *indx, float *y);

#ifdef FORTRAN_FLOAT_FUNCTIONS_RETURN_DOUBLE
extern double SDOTI(int *nz, float *x, int *indx, float *y);
#else
extern float SDOTI(int *nz, float *x, int *indx, float *y);
#endif

extern void SGTHR(int *nz, float *y, float *x, int *indx);
extern void SGTHRZ(int *nz, float *y, float *x, int *indx);
extern void SROTI(int *nz, float *x, int *indx, float *y, float *c, float *s);
extern void SSCTR(int *nz, float *x, int *indx, float *y);
extern void ZAXPYI(int *nz, doublecomplex *a, doublecomplex *x, int *indx, doublecomplex *y);
extern doublecomplex ZDOTCI(doublecomplex *ret_val, int *nz, doublecomplex *x, int *indx, doublecomplex *y);
extern void ZDOTCISUB(doublecomplex *ret_val, int *nz, doublecomplex *x, int *indx, doublecomplex *y);
extern doublecomplex ZDOTUI(doublecomplex *ret_val, int *nz, doublecomplex *x, int *indx, doublecomplex *y);
extern void ZDOTUISUB(doublecomplex *ret_val, int *nz, doublecomplex *x, int *indx, doublecomplex *y);
extern void ZGTHR(int *nz, doublecomplex *y, doublecomplex *x, int *indx);
extern void ZGTHRZ(int *nz, doublecomplex *y, doublecomplex *x, int *indx);
extern void ZSCTR(int *nz, doublecomplex *x, int *indx, doublecomplex *y);

/* Random number generators */
extern void DRANDBETA(int *n, double *a, double *b, int *state, double *x, int *info);
extern void DRANDBINOMIAL(int *n, int *m, double *p, int *state, int *x, int *info);
extern void DRANDBINOMIALREFERENCE(int *m, double *p, double *ref, int *lref, int *info);
extern void DRANDBLUMBLUMSHUB(int *n, int *state, double *x, int *info);
extern void DRANDCAUCHY(int *n, double *a, double *b, int *state, double *x, int *info);
extern void DRANDCHISQUARED(int *n, int *df, int *state, double *x, int *info);
extern void DRANDDISCRETEUNIFORM(int *n, int *a, int *b, int *state, int *x, int *info);
extern void DRANDEXPONENTIAL(int *n, double *a, int *state, double *x, int *info);
extern void DRANDF(int *n, int *df1, int *df2, int *state, double *x, int *info);
extern void DRANDGAMMA(int *n, double *a, double *b, int *state, double *x, int *info);
extern void DRANDGAUSSIAN(int *n, double *xmu, double *var, int *state, double *x, int *info);
extern void DRANDGENERALDISCRETE(int *n, double *ref, int *state, int *x, int *info);
extern void DRANDGEOMETRIC(int *n, double *p, int *state, int *x, int *info);
extern void DRANDGEOMETRICREFERENCE(double *p, double *ref, int *lref, int *info);
extern void DRANDHYPERGEOMETRIC(int *n, int *np, int *ns, int *m, int *state, int *x, int *info);
extern void DRANDHYPERGEOMETRICREFERENCE(int *np, int *ns, int *m, double *ref, int *lref, int *info);
extern void DRANDINITIALIZE(int *genid, int *subid, int *seed, int *lseed, int *state, int *lstate, int *info);
extern void DRANDINITIALIZEBBS(int *nbits, int *lp, int *p, int *lq, int *q, int *ls, int *s, int *state, int *lstate, int *info);
extern void DRANDINITIALIZEUSER(ACML_DRANDINITIALIZEUSER_UINI uini, ACML_DRANDINITIALIZEUSER_UGEN ugen, int genid, int subid, int *seed, int *lseed, int *state, int *lstate, int *info);
extern void DRANDLEAPFROG(int *n, int *k, int *state, int *info);
extern void DRANDLOGISTIC(int *n, double *a, double *b, int *state, double *x, int *info);
extern void DRANDLOGNORMAL(int *n, double *xmu, double *var, int *state, double *x, int *info);
extern void DRANDMULTINOMIAL(int *n, int *m, double *p, int *k, int *state, int *x, int *ldx, int *info);
extern void DRANDMULTINORMALREFERENCE(int *m, double *xmu, double *c, int *ldc, double *ref, int *lref, int *info);
extern void DRANDMULTINORMALR(int *n, double *ref, int *state, double *x, int *ldx, int *info);
extern void DRANDMULTISTUDENTSTREFERENCE(int *m, int *df, double *xmu, double *c, int *ldc, double *ref, int *lref, int *info);
extern void DRANDMULTISTUDENTSTR(int *n, double *ref, int *state, double *x, int *ldx, int *info);
extern void DRANDNEGATIVEBINOMIAL(int *n, int *m, double *p, int *state, int *x, int *info);
extern void DRANDNEGATIVEBINOMIALREFERENCE(int *m, double *p, double *ref, int *lref, int *info);
extern void DRANDPOISSON(int *n, double *lambda, int *state, int *x, int *info);
extern void DRANDPOISSONREFERENCE(double *lambda, double *ref, int *lref, int *info);
extern void DRANDSKIPAHEAD(int *n, int *state, int *info);
extern void DRANDSTUDENTST(int *n, int *df, int *state, double *x, int *info);
extern void DRANDTRIANGULAR(int *n, double *xmin, double *xmed, double *xmax, int *state, double *x, int *info);
extern void DRANDUNIFORM(int *n, double *a, double *b, int *state, double *x, int *info);
extern void DRANDVONMISES(int *n, double *vk, int *state, double *x, int *info);
extern void DRANDWEIBULL(int *n, double *a, double *b, int *state, double *x, int *info);
extern void DRANDMULTINORMAL(int *n, int *m, double *xmu, double *c, int *ldc, int *state, double *x, int *ldx, int *info);
extern void DRANDMULTISTUDENTST(int *n, int *m, int *df, double *xmu, double *c, int *ldc, int *state, double *x, int *ldx, int *info);
extern void SRANDBETA(int *n, float *a, float *b, int *state, float *x, int *info);
extern void SRANDBLUMBLUMSHUB(int *n, int *state, float *x, int *info);
extern void SRANDBINOMIAL(int *n, int *m, float *p, int *state, int *x, int *info);
extern void SRANDBINOMIALREFERENCE(int *m, float *p, float *ref, int *lref, int *info);
extern void SRANDCAUCHY(int *n, float *a, float *b, int *state, float *x, int *info);
extern void SRANDCHISQUARED(int *n, int *df, int *state, float *x, int *info);
extern void SRANDDISCRETEUNIFORM(int *n, int *a, int *b, int *state, int *x, int *info);
extern void SRANDEXPONENTIAL(int *n, float *a, int *state, float *x, int *info);
extern void SRANDF(int *n, int *df1, int *df2, int *state, float *x, int *info);
extern void SRANDGAMMA(int *n, float *a, float *b, int *state, float *x, int *info);
extern void SRANDGAUSSIAN(int *n, float *xmu, float *var, int *state, float *x, int *info);
extern void SRANDGENERALDISCRETE(int *n, float *ref, int *state, int *x, int *info);
extern void SRANDGEOMETRIC(int *n, float *p, int *state, int *x, int *info);
extern void SRANDGEOMETRICREFERENCE(float *p, float *ref, int *lref, int *info);
extern void SRANDHYPERGEOMETRIC(int *n, int *np, int *ns, int *m, int *state, int *x, int *info);
extern void SRANDHYPERGEOMETRICREFERENCE(int *np, int *ns, int *m, float *ref, int *lref, int *info);
extern void SRANDINITIALIZE(int *genid, int *subid, int *seed, int *lseed, int *state, int *lstate, int *info);
extern void SRANDINITIALIZEBBS(int *nbits, int *lp, int *p, int *lq, int *q, int *ls, int *s, int *state, int *lstate, int *info);
extern void SRANDINITIALIZEUSER(ACML_SRANDINITIALIZEUSER_UINI uini, ACML_SRANDINITIALIZEUSER_UGEN ugen, int genid, int subid, int *seed, int *lseed, int *state, int *lstate, int *info);
extern void SRANDLEAPFROG(int *n, int *k, int *state, int *info);
extern void SRANDLOGISTIC(int *n, float *a, float *b, int *state, float *x, int *info);
extern void SRANDLOGNORMAL(int *n, float *xmu, float *var, int *state, float *x, int *info);
extern void SRANDMULTINOMIAL(int *n, int *m, float *p, int *k, int *state, int *x, int *ldx, int *info);
extern void SRANDMULTINORMALREFERENCE(int *m, float *xmu, float *c, int *ldc, float *ref, int *lref, int *info);
extern void SRANDMULTINORMALR(int *n, float *ref, int *state, float *x, int *ldx, int *info);
extern void SRANDMULTISTUDENTSTREFERENCE(int *m, int *df, float *xmu, float *c, int *ldc, float *ref, int *lref, int *info);
extern void SRANDMULTISTUDENTSTR(int *n, float *ref, int *state, float *x, int *ldx, int *info);
extern void SRANDNEGATIVEBINOMIAL(int *n, int *m, float *p, int *state, int *x, int *info);
extern void SRANDNEGATIVEBINOMIALREFERENCE(int *m, float *p, float *ref, int *lref, int *info);
extern void SRANDPOISSON(int *n, float *lambda, int *state, int *x, int *info);
extern void SRANDPOISSONREFERENCE(float *lambda, float *ref, int *lref, int *info);
extern void SRANDSKIPAHEAD(int *n, int *state, int *info);
extern void SRANDSTUDENTST(int *n, int *df, int *state, float *x, int *info);
extern void SRANDTRIANGULAR(int *n, float *xmin, float *xmed, float *xmax, int *state, float *x, int *info);
extern void SRANDUNIFORM(int *n, float *a, float *b, int *state, float *x, int *info);
extern void SRANDVONMISES(int *n, float *vk, int *state, float *x, int *info);
extern void SRANDWEIBULL(int *n, float *a, float *b, int *state, float *x, int *info);
extern void SRANDMULTINORMAL(int *n, int *m, float *xmu, float *c, int *ldc, int *state, float *x, int *ldx, int *info);
extern void SRANDMULTISTUDENTST(int *n, int *m, int *df, float *xmu, float *c, int *ldc, int *state, float *x, int *ldx, int *info);

/* ACML version information */
extern void ACMLVERSION(int *major, int *minor, int *patch);
extern void ACMLINFO(void);

/* OMP interfaces */
extern int ACMLGETMAXTHREADS(void);
extern int ACMLGETNUMTHREADS(void);
extern void ACMLSETNUMTHREADS(int *numthreads);
extern int ACMLGETNUMPROCS(void);

/* Putenv and getenv utilities */
extern void ACMLPUTENV(char *name, char *value, int name_len, int value_len);
extern void ACMLGETENV(char *name, char *value, int name_len, int value_len);
extern void ACMLLOCATION(char *message, void *arg, int message_len);
extern void ACMLLOCATIONSTRING(char *message, void *arg, char *string, int message_len, int string_len);
/* ------------------------------------------------------------------ */

#ifdef __cplusplus
}
#endif /* __cplusplus */

#endif /* !defined(_ACML_H) */
